2012 – 2026

TypeScript Versions

Every public release of TypeScript — from TypeScript 0.8 in October 2012 through TypeScript 7.0 in July 2026 — with ship dates and the headline type-system features per version. Plus Anders Hejlsberg's design lineage, the AtScript merger with Google's Angular team, the strictNullChecks revolution, the conditional-types and template-literal-types eras, the decorators-stage-3 long road, the native-TypeScript-in-runtimes wave, and the Go-rewrite that shipped stable as TypeScript 7.0 in July 2026.

Era

Pre-2.0 — TypeScript 0.8 – 1.8, 2012–2016, before strictNullChecks
Inference — TypeScript 2.0 – 3.9, 2016–2020, the type-system-maturity era (mapped types, conditional types, optional chaining)
Modern — TypeScript 4.0+, 2020 onward, template literal types and the modern toolchain era

TypeScript has no formal LTS or end-of-life policy. Microsoft supports "the latest" and the project ships on a roughly quarterly cadence; the practical advice is to upgrade with each minor release. See the TypeScript blog for per-release announcements and github.com/microsoft/TypeScript/releases for ship dates.

TypeScript version table

Version
TypeScript 7.0
Modern
Jul 8, 2026
Latest release. The Go-native compiler ships stable — 8–12x faster full builds, new --checkers/--builders/--singleThreaded parallelism controls, a rebuilt Parcel-based --watch. No public API yet, so template-embedding tools (Vue, Astro, Svelte, Angular) stay on 6.0 for now.
  • The Go-native port ships as TypeScript 7.0 — announced July 8, 2026, about a year and four months after the March 2025 rewrite announcement. Microsoft's own benchmarks on real-world codebases: vscode 125.7s → 10.6s (11.9x), sentry 8.9x, bluesky 8.7x, playwright 8.7x, tldraw 7.7x on full builds, with 6–26% lower peak memory; opening a file with an error in the vscode codebase drops from ~17.5s to ~1.3s (13x).
  • No new public API yet — 7.0 ships its own tsc binary but no programmatic API; that's targeted for 7.1. A new @typescript/typescript6 compatibility package (with a tsc6 binary and a re-export of the 6.0 API) lets tools like typescript-eslint keep working side-by-side via npm aliasing. Nightly builds move from the standalone @typescript/native-preview package to the standard typescript package's next tag.
  • --checkers, --builders, and --singleThreaded — new flags to tune parallel type-checking workers (default 4), parallel project-reference builds, and an escape hatch back to fully single-threaded compilation for debugging or constrained CI runners. --checkers and --builders ship marked experimental; --stableTypeOrdering is now on by default and cannot be turned off.
  • Rebuilt --watch mode — a Go port of the Parcel bundler's file-watcher, replacing the old polling-based approach with efficient, stable cross-platform file watching.
  • 6.0's new defaults are hardened into hard errors — target: es5, downlevelIteration, moduleResolution: node/node10/classic, module: amd/umd/systemjs/none, and a disabled baseUrl all stop working rather than warn; rootDir now defaults to ./ and types defaults to [].
  • Template literal types now preserve full Unicode code points when inferring from strings — matching against "😀abc" now infers the head as the whole emoji instead of splitting its UTF-16 surrogate pair. A breaking change for any type-level string-length utility that depended on the old UTF-16 behavior.
  • The current published version is 7.0.2 (npm, Jul 8, 2026); the RC (7.0.1-rc, Jun 18, 2026) and Beta (Apr 21, 2026) precede it. Editor support ships as a dedicated VS Code extension (auto-default on install) with Visual Studio auto-enabling per-workspace; embedding tools (Vue/Volar, MDX, Astro, Svelte, Angular templates) stay on the TypeScript 6.0 language service until 7.1's API lands.
Version
TypeScript 6.0
Modern
Mar 23, 2026
The final JavaScript-codebase compiler — the default until TypeScript 7.0 shipped stable in July 2026. --strict on by default; module defaults to esnext; target becomes a floating current-year default (es2025 today). Also adds the es2025 target/lib and built-in Temporal types.
  • The final JavaScript-codebase release of TypeScript — clears the deck for the Go-native 7.0, which shipped stable on July 8, 2026 after a public Beta (April 21) and Release Candidate (June 18). From 7.0 forward, tsc ships as a Go binary with shared-memory multi-threaded type checking.
  • --strict is on by default — new projects opt out instead of opting in; the long-running default-flag debate that began with the introduction of --strictNullChecks in 2.0 (2016) finally lands.
  • New defaults: module defaults to esnext (was commonjs); target becomes a floating default — "the most recent supported ECMAScript spec version," which is es2025 today — instead of the ES5 it had been for a decade; rootDir defaults to the tsconfig.json directory; types defaults to []; noUncheckedSideEffectImports flips on and libReplacement flips off. The legacy default-set that newcomers stumbled over is finally retired.
  • New es2025 target and lib — no new language syntax, but new types for built-in APIs like RegExp.escape, and Promise.try, the Iterator helpers, and the Set methods graduate out of esnext. That remains the newest numbered ECMAScript target: as of July 2026 there is still no es2026 option for target or lib, even though ES2026 was ratified as the 17th edition in June 2026.
  • Built-in Temporal types — the date-and-time replacement for Date ships type definitions under --target esnext / "lib": ["esnext"] (or the granular esnext.temporal). Temporal reached TC39 Stage 4 in May 2026 and is slated for ES2027, which is why it sits in esnext rather than a numbered lib.
  • --stableTypeOrdering compiler flag — introduced specifically to help compare emit and diagnostic output between the JS-based 6.0 compiler and the Go-based 7.0 compiler, since the native port uses content-based deterministic ordering instead of the JS compiler's encounter-order. Useful for any toolchain that snapshots TS output.
  • Benchmarked at ~40–60% faster incremental compilation, ~25% lower memory use, and ~30% faster editor operations vs. 5.x baseline (Microsoft figures).
  • The current patch release is 6.0.3 (Apr 16, 2026); 6.0.0 was the Beta, 6.0.1 the RC, 6.0.2 the first Stable on Mar 23, 2026.
Version
TypeScript 5.9
Modern
Aug 1, 2025
import defer; --module node20; minimal tsc --init; expandable hover tooltips; DOM API descriptions from MDN.
  • import defer support — import defer * as ns from "./mod", matching the TC39 deferred-module-evaluation proposal. Imports a module without immediately executing it or its dependencies; properties access on the namespace triggers evaluation lazily. Useful for cold-start optimization.
  • --module node20 — a fixed, predictable module-resolution mode pinned to Node 20's behavior (vs. the floating --module nodenext which moves with Node releases). Implies --target es2023 by default.
  • Minimal tsc --init — the generated tsconfig.json is now far more concise and prescriptive, matching what most projects actually want.
  • Expandable hover tooltips ("quick info verbosity") — +/- buttons on type tooltips let you drill into nested types in place without jumping to the definition.
  • DOM API descriptions from MDN — built-in lib types now ship with summary documentation, so hover-help on Element.prototype.querySelector shows the MDN one-liner.
  • Performance: cached-instantiations on type mappers; ~11% speedup on file-existence checks for large projects.
  • Last 5.x release; 6.0 followed in March 2026 as the final JavaScript-codebase compiler.
Version
TypeScript 5.8
Modern
Feb 28, 2025
Granular control over module / moduleResolution; require() of ESM in CommonJS; conditional type optimizations.
  • Granular checks for branches in return expressions — control flow analysis catches more cases where one branch returns and the other implicitly doesn't, particularly with throw in switches.
  • Path rewriting refinements for --rewriteRelativeImportExtensions introduced in 5.7 — safer interop with bundlers and Node ESM.
  • --module node18 stabilized as a recommended target for Node 18+ projects without changing moduleResolution behavior unexpectedly.
  • Performance improvements in conditional-type instantiation; faster --noCheck emit for declaration-only builds.
  • Build-mode and TS Server polishing across the editor experience.
Version
TypeScript 5.7
Modern
Nov 22, 2024
--rewriteRelativeImportExtensions; never-initialized-variables checks; target: ES2024.
  • --rewriteRelativeImportExtensions — rewrites .ts/.tsx/.mts/.cts import extensions to their JS counterparts at emit time, finally enabling source written for native-TS Node / Bun to be compiled for traditional bundler output.
  • Checks for never-initialized variables — flags let x; followed by code that reads x before any assignment.
  • target: ES2024 — the new ECMAScript edition becomes a supported compile target.
  • Path rewriting works alongside --moduleResolution: bundler; new --module preserve mode.
  • Significant editor-side improvements: auto-import refinements, faster goto-definition.
Version
TypeScript 5.6
Modern
Sep 9, 2024
Disallowed nullish/truthy checks; iterator helpers; --isolatedDeclarations; --stopOnBuildErrors.
  • Disallowed nullish and truthy checks — if (x && y) where x is always truthy raises a warning; reduces a class of bug-prone always-true conditionals.
  • --isolatedDeclarations — opt into a stricter mode that requires explicit type annotations on exported APIs; enables fast parallel .d.ts generation by third-party tools without a full type check — Oxc's oxc_isolated_declarations crate is one such implementation.
  • Iterator helpers — Iterator.prototype.{map, filter, take, drop, ...} typed and emitted correctly for ES2025.
  • --stopOnBuildErrors in build mode — first-error aborts large multi-project builds.
  • Region-prioritized diagnostics in the TS Server — the editor surfaces errors near the cursor first.
Version
TypeScript 5.5
Modern
Jun 20, 2024
Inferred type predicates; control flow narrowing for index access; regex syntax checking.
  • Inferred type predicates — functions with an explicit boolean return based on a discriminating check now infer a arg is T predicate automatically. const isString = (x: unknown) => typeof x === 'string' finally narrows correctly without an explicit annotation.
  • Control flow narrowing for constant indexed accesses — if you check obj[k] and k is a constant, subsequent uses of obj[k] get the narrowed type.
  • Regex syntax checking — the compiler validates regular expression literals against the spec; catches /\d{10,5}/-style invalid quantifiers at compile time.
  • JSDoc @import tag for type-only imports in JS files; --isolatedDeclarations hardening.
  • Quick-fix to add missing parameter; "Move declaration" refactor.
Version
TypeScript 5.4
Modern
Mar 6, 2024
NoInfer utility type; preserved narrowing in closures; new Object.groupBy / Map.groupBy typings.
  • NoInfer<T> utility type — opts a generic position out of inference so the caller has to specify it elsewhere. The "default value but don't infer from this argument" pattern finally has a sanctioned solution.
  • Preserved narrowing in closures — narrowed types survive into nested function expressions when the narrowed value is captured in a stable position. The single most common "TS forgot what it knew" footgun, fixed.
  • Object.groupBy and Map.groupBy typed for ES2024.
  • --moduleResolution bundler hardening; auto-import improvements that prefer subpath patterns.
  • The --module preserve work begins (lands fully in 5.5+).
Version
TypeScript 5.3
Modern
Nov 20, 2023
Import attributes (replacing assertions); switch (true) narrowing.
  • Import attributes — the standardized replacement for the older import assertions syntax. import config from "./config.json" with { type: "json" } as part of the TC39 Stage 3 proposal.
  • switch (true) narrowing — the discriminating-pattern idiom now narrows correctly across cases. switch (true) { case typeof x === 'string': ... }.
  • Narrowing on comparisons to boolean and numeric literals.
  • Optimizations for instantiation expressions.
  • Stable resolution-mode assertions for individual imports.
Version
TypeScript 5.2
Modern
Aug 24, 2023
using / await using declarations (explicit resource management); decorator metadata.
  • using and await using declarations — explicit resource management, implemented from the TC39 proposal while it was still at Stage 3. Calls Symbol.dispose/Symbol.asyncDispose at the end of the enclosing scope. Python's with / C#'s using finally arrives in JavaScript. The proposal reached Stage 4 on May 19, 2026 and is slated for ES2027, not ES2026 — TypeScript still exposes the types under lib.esnext.disposable.
  • Decorator metadata — the context.metadata object on the Stage 3 decorators introduced in 5.0 is now populated with a metadata bag that survives reflection.
  • Named and anonymous tuple elements can be mixed (the elements that have names and elements that don't).
  • Easier method usage for unions of arrays.
  • Stable copy-by-array-method typings; --moduleResolution: bundler for monorepos.
Version
TypeScript 5.1
Modern
Jun 1, 2023
Easier implicit returns; unrelated types for getters/setters; @namespaced JSX elements.
  • Easier implicit returns for undefined-returning functions — the common React-component pattern (function MyComp() { if (cond) return null; }) no longer requires an explicit return on every branch.
  • Unrelated types for getters and setters — a get can return one type and set can accept a different type; aligns with the JavaScript reality of asymmetric property accessors.
  • Decoupled type-checking between JSX elements and JSX tag types; namespaced JSX attributes.
  • @param JSDoc inference improvements.
Version
TypeScript 5.0
Modern
Mar 16, 2023
Stage-3 decorators; const type parameters; --moduleResolution bundler; smaller npm package.
  • Decorators (Stage 3 TC39) — the long-running decorators saga (experimental in 1.5, Stage 2 reset in 2018, Stage 3 acceptance in 2022) finally lands as a non-experimental, spec-compliant feature. The TypeScript-experimental decorators (under --experimentalDecorators) remain available for backward compatibility but are no longer the recommended path. TC39 later moved the proposal back to Stage 2.7 (May 2026) for lack of any engine implementation — see the decorators history below.
  • const type parameters — function f<const T>(x: T) infers the most-specific (readonly tuple, literal type) version of T instead of widening to string[] or string.
  • --moduleResolution bundler — the new resolution mode designed to match what bundlers (esbuild, swc, Vite, Webpack) actually do, replacing the older node mode that was diverging.
  • --verbatimModuleSyntax replaces the earlier importsNotUsedAsValues + preserveValueImports combo with a single coherent flag.
  • Smaller npm package and faster compilation — ~20% smaller install, modest speedups across the board after a multi-release Internal Node refactor.
  • --moduleSuffixes, --allowImportingTsExtensions, JSDoc @satisfies and @overload.

The 4.x line and the modern type-system era — August 2020. Above this line: the Modern era, opened by the variadic-tuple-types and template-literal-types pair (4.0 and 4.1) and continuing through the satisfies operator (4.9), Stage-3 decorators (5.0), and the explicit-resource-management using syntax (5.2). Below: the Inference era of mapped types, conditional types, and optional chaining that ran through the 2.x and 3.x lines. The boundary is editorial, not technical — the type system has been a continuous evolution — but the modern toolchain era (esbuild, Vite, Bun, native-TS in Node) coalesced around the same time.

Version
TypeScript 4.9
Modern
Nov 15, 2022
The satisfies operator; auto-accessors in classes; in operator narrowing.
  • The satisfies operator — const palette = { red: "#f00", blue: "#00f" } satisfies Record<string, string> validates a value against a constraint while preserving its specific inferred type. The single most-celebrated TS feature since template literal types — finally a sanctioned solution to the "I want to validate but not widen" pattern.
  • Auto-accessors in classes — accessor x: string generates a getter/setter pair backed by a private field, matching the TC39 Stage 3 decorators proposal.
  • Unlisted property narrowing via in — if ("foo" in obj) narrows even when foo isn't declared on the type.
  • NaN equality checks errors; minor file-watching improvements.
  • Last 4.x release; 5.0 followed in March 2023.
Version
TypeScript 4.8
Modern
Aug 25, 2022
Improved intersection narrowing; better --build mode; type inference for infer-extends-constraint.
  • Improved intersection narrowing in template literals — combining narrowed string types with template literal patterns produces tighter results.
  • Improved infer type extraction — infer T extends string constraints simplify to the constraint instead of an intersection.
  • Bind, call, and apply on functions with rest parameters; first-class file-watching improvements.
  • --build mode performance work.
Version
TypeScript 4.7
Modern
May 24, 2022
Node.js ESM support (.mts/.cts); moduleResolution: node16; instantiation expressions.
  • Node.js ESM support stabilizes — new module: node16 and nodenext values; new .mts and .cts file extensions for unambiguously-typed ES modules and CommonJS modules; package.json "type": "module" integration. The Node-side ESM-vs-CJS interop story finally has a sanctioned TS shape.
  • Instantiation expressions — const stringMap = Map<string> as a way to pre-instantiate a generic type. Useful for type-only aliases and for narrowing factory functions.
  • Control flow analysis for computed properties — narrowing across obj[k] when k is a literal.
  • Variance modifiers in type parameters (in, out); resolution customization for individual imports.
Version
TypeScript 4.6
Modern
Feb 28, 2022
Allow code in constructors before super(); control flow analysis for destructured discriminated unions.
  • Code in constructors before super() — statements that don't reference this are now allowed before the parent-constructor call. Long-running annoyance for class-component patterns finally fixed.
  • Control flow analysis for destructured discriminated unions — const { kind, value } = obj; switch (kind) { ... } now narrows value correctly across cases.
  • JSDoc enhancements for type imports.
  • Indexed-access inference improvements for default-typed generics.
Version
TypeScript 4.5
Modern
Nov 17, 2021
Awaited<T> utility type; ES module preview in Node; private-field presence checks.
  • Awaited<T> utility type — correctly unwraps nested Promise types. Replaces the long-standing community workaround patterns.
  • ES modules in Node 12+ preview — module: nodenext as the experimental knob; foundation for the 4.7 stable Node-ESM story.
  • Private field presence checks — #field in obj narrowing.
  • Tail-recursion elimination on conditional types — recursionDepth error finally goes away for many real-world cases.
  • Snippet completions for method overrides; type-only modifier on import names.
Version
TypeScript 4.4
Modern
Aug 26, 2021
Control flow analysis of aliased conditions; symbol/template-literal index signatures; --useUnknownInCatchVariables.
  • Control flow analysis of aliased conditions — const isString = typeof x === "string"; if (isString) { ... } narrows x inside the conditional.
  • Symbol and template-literal index signatures — { [k: `data-${string}`]: string } in object types.
  • --useUnknownInCatchVariables — defaults catch (e) bindings to unknown instead of any.
  • Static blocks in classes — static { ... } initializers for static state setup.
  • Inlay hints in editors.
Version
TypeScript 4.3
Modern
May 26, 2021
Separate write types on properties; override keyword; static index signatures.
  • Separate write types on properties — getters and setters can have different types in interfaces and type literals (precursor to 5.1's full unrelated-types).
  • override keyword and --noImplicitOverride — explicit method-override declarations, finally catching the rename-method-but-forget-to-update-subclasses class of bug.
  • Static index signatures on classes.
  • type modifier on import / export names.
  • Improved completion list for indexed-access types.
Version
TypeScript 4.2
Modern
Feb 23, 2021
Smarter type alias preservation; leading/middle rest elements in tuples; stricter in.
  • Smarter type alias preservation in displayed types — the compiler keeps the original alias name in error messages instead of expanding to a structural form.
  • Leading and middle rest elements in tuple types — [...string[], number] and [number, ...string[], boolean].
  • Stricter checks for the in operator (only allows valid keys).
  • noPropertyAccessFromIndexSignature compiler flag.
  • Abstract construct signatures.
Version
TypeScript 4.1
Modern
Nov 19, 2020
Template literal types; key remapping in mapped types; recursive conditional types; checked indexed accesses.
  • Template literal types — type Greeting = `Hello, ${Name}`. Combined with conditional types and infer, this turns the type system into a full string-manipulation language. The single largest type-system feature since conditional types in 2.8; the basis for libraries like Zod, tRPC, and Effect that compute precise types from string keys.
  • Key remapping in mapped types — { [K in keyof T as `get${Capitalize<K>}`]: () => T[K] }. Combined with template literal types, the recipe for type-driven API generation.
  • Recursive conditional types — types that recurse on themselves with explicit termination, enabling things like Awaited<T> (which became a built-in utility type in 4.5).
  • --noUncheckedIndexedAccess — arr[0] returns T | undefined instead of T. The "what TypeScript should have done all along" indexed-access correctness flag.
  • JSX factory configuration via jsxImportSource.
Version
TypeScript 4.0
Modern
Aug 20, 2020
Variadic tuple types; labeled tuple elements; class-property inference from constructors.
  • Variadic tuple types — type Concat<T extends unknown[], U extends unknown[]> = [...T, ...U]. The foundation for properly typing function composition, currying, partial application, and a long tail of higher-order generic patterns.
  • Labeled tuple elements — type Range = [start: number, end: number]. Names show up in editor tooltips and signature help.
  • Class property inference from constructors — declared but uninitialized properties get their type from constructor assignments, reducing the boilerplate of x: number; constructor(x: number) { this.x = x; }.
  • Short-circuiting assignment operators — &&=, ||=, ??= from ES2021.
  • 4.0 was named the new major because the 3.x line had grown the type system substantially without taking a major-version step; not a breaking change in the SemVer sense (TypeScript explicitly does not do SemVer for the language).
Version
TypeScript 3.9
Inference
May 12, 2020
Speed improvements; Promise.all inference; @ts-expect-error; uncalled function checks.
  • Speed improvements — ~40% faster on large React + Material UI codebases; bundled in npm install size shrank notably.
  • Improvements to Promise.all inference (lined up with the JS spec).
  • // @ts-expect-error directive — like @ts-ignore but errors if the next line is actually fine, catching stale suppressions.
  • New uncalled-function checks (catches if (obj.method) when method is required).
  • Last 3.x release; 4.0 followed in August 2020.
Version
TypeScript 3.8
Inference
Feb 20, 2020
Type-only imports / exports; ECMAScript private fields (#name); top-level await; export-as-namespace-from.
  • Type-only imports and exports — import type { Foo } from "./foo" guarantees zero runtime emit. Cornerstone of the modern bundler-friendly TS dialect.
  • ECMAScript private fields — #name hard private (vs. the older TS-only private).
  • Top-level await in modules.
  • export * as ns from "..." namespace re-export syntax.
  • --watch incremental and assumeChangesOnlyAffectDirectDependencies for huge codebases.
Version
TypeScript 3.7
Inference
Nov 5, 2019
Optional chaining (?.); nullish coalescing (??); assertion functions; better recursive type aliases.
  • Optional chaining (?.) — obj?.prop?.method?.(). The "TypeScript shipped this before V8 did" feature; landed in the spec at TC39 Stage 4 contemporaneously. Eliminated a generation of "cannot read property of undefined" boilerplate.
  • Nullish coalescing (??) — x ?? "default" falls back only on null/undefined (unlike || which falls back on any falsy). Co-shipped with optional chaining.
  • Assertion functions — function assert(x: unknown): asserts x. The asserts return-type modifier as a way to communicate "this function throws if the condition fails" to the type system.
  • Better support for recursive type aliases (precursor to 4.1's recursive conditional types).
  • // @ts-nocheck for entire files; uncalled-function-check predecessor.
Version
TypeScript 3.6
Inference
Aug 28, 2019
Stricter generators; more accurate array spread; broader Unicode for identifiers.
  • Stricter typing for generators and iterators — the TReturn and TNext generic parameters become accessible.
  • More accurate array spread for ES5 targets.
  • Broader Unicode identifier support.
  • Improved UIEvents / JSX typings; "smart" auto-import.
Version
TypeScript 3.5
Inference
May 29, 2019
Speed improvements; Omit utility type; improved excess-property checks in unions.
  • Omit<T, K> utility type — type Without = Omit<Original, "field">. The most-requested utility type for years; now first-party.
  • Substantial type-checking speed improvements.
  • Improved excess-property checks in union types.
  • Better handling of --incremental with composite projects.
Version
TypeScript 3.4
Inference
Mar 29, 2019
const assertions; readonly tuples and arrays; type-checking globalThis.
  • const assertions — const obj = { x: 0, y: 0 } as const infers literal types, makes properties readonly, and freezes arrays into tuples. The "give me the most specific possible type" lever; cornerstone pattern in modern TS.
  • Readonly tuples and arrays — readonly [number, number] as a first-class type.
  • Type-checked globalThis.
  • Incremental builds with --incremental stable.
  • Higher-order type inference improvements for generic functions composed with pipe/compose.
Version
TypeScript 3.3
Inference
Jan 31, 2019
Improved behavior for calling union types; incremental file watching.
  • Better support for calling union types.
  • Faster incremental file-watching; foundation for the --incremental stabilization in 3.4.
Version
TypeScript 3.2
Inference
Nov 29, 2018
Strict bind/call/apply with generics; object spread on generics; BigInt support.
  • Strictly typed bind, call, and apply for generic functions.
  • Object spread on generic types.
  • BigInt as a primitive type.
  • Improved error reporting around tuples and nested types.
Version
TypeScript 3.1
Inference
Sep 27, 2018
Mapped types on tuples and arrays; property declarations on functions.
  • Mapped types over tuples and arrays preserve the original shape.
  • Property declarations on functions (function foo() {}; foo.bar = 1) typed automatically.
  • typesVersions field in package.json for per-TS-version type definitions.
Version
TypeScript 3.0
Inference
Jul 30, 2018
Project references; unknown type; tuple type rest elements; generic rest parameters.
  • Project references — references: [...] in tsconfig.json with --build mode for incremental cross-project compilation. The structural answer to monorepo-shaped TypeScript projects.
  • unknown type — the type-safe counterpart to any; assignable from anything but not assignable to anything without a check.
  • Tuple type rest elements — type T = [string, ...number[]].
  • Generic rest parameters — function f<T extends unknown[]>(...args: T); foundation for variadic-tuple work that landed in 4.0.
  • JSX 3.0 with --jsx react-jsx (the new JSX transform Microsoft contributed to React).
Version
TypeScript 2.9
Inference
May 31, 2018
keyof over number / symbol; import() expressions; --resolveJsonModule.
  • keyof over numeric and symbol-keyed properties.
  • import("./module") as a type expression.
  • --resolveJsonModule — type-safe JSON imports.
  • Tagged template inference improvements; const-narrow refinements.
Version
TypeScript 2.8
Inference
Mar 27, 2018
Conditional types; infer keyword; mapped type modifiers.
  • Conditional types — type T<X> = X extends Y ? A : B. The single largest type-system feature since strictNullChecks; opens the door to the dialect of "type-level programming" that has come to define modern TypeScript libraries (Zod, tRPC, Effect, Drizzle).
  • infer keyword — pattern-extraction from types: type ReturnType<F> = F extends (...a: any) => infer R ? R : never.
  • Distributive conditional types — conditional types automatically distribute over union types in the input.
  • Mapped type modifiers — +readonly, -readonly, +?, -? for adding/removing modifiers.
  • Pre-defined utility types: Exclude<T, U>, Extract<T, U>, NonNullable<T>, ReturnType<T>, InstanceType<T>.
  • --emitDeclarationOnly for monorepos.
Version
TypeScript 2.7
Inference
Jan 31, 2018
Constant-named properties; unique symbol; strict class initialization.
  • Constant-named properties: const-keyed indexed access types.
  • unique symbol — nominal-style symbol types for branded keys.
  • Strict class initialization (--strictPropertyInitialization) — class fields must be definitely assigned in the constructor or marked optional.
  • Easier ECMAScript module interop with --esModuleInterop.
Version
TypeScript 2.6
Inference
Oct 31, 2017
--strictFunctionTypes; // @ts-ignore; cached tagged template literals.
  • --strictFunctionTypes — sound contravariant parameter checking. Catches the long-standing soundness hole in callback-position function types.
  • // @ts-ignore — suppress an error on the next line. The escape hatch most developers reach for first.
  • Cached tagged template literals.
Version
TypeScript 2.5
Inference
Aug 31, 2017
Optional catch clause variables; modular language service.
  • Optional catch clause variables — try { ... } catch { ... }.
  • Modular language service architecture — the foundation for downstream tools that embed TS as a service.
Version
TypeScript 2.4
Inference
Jun 27, 2017
Dynamic import() expressions; string enums; improved generic inference.
  • Dynamic import() expressions for code splitting.
  • String enums — enum E { A = "a", B = "b" }. Disambiguates the original numeric-only enum design.
  • Significant inference improvements for generic functions.
Version
TypeScript 2.3
Inference
Apr 27, 2017
Generators in ES5/ES3; --strict; --checkJs for typing JavaScript.
  • Async generators and async iterators downleveled to ES5/ES3.
  • --strict — turn on every strict-mode flag at once. The single most impactful flag for new projects.
  • --checkJs and // @ts-check — type-check plain JavaScript files using JSDoc types.
Version
TypeScript 2.2
Inference
Feb 22, 2017
Mixin classes; object type.
  • Mixin classes — sanctioned typing for the function Mix(Base) { return class extends Base {} } pattern.
  • The object type — "non-primitive type" (anything that's not string/number/boolean/symbol/null/undefined).
Version
TypeScript 2.1
Inference
Dec 7, 2016
keyof operator; mapped types; object spread/rest; downlevel async/await.
  • keyof operator — type Keys = keyof MyType. Foundation for type-level reasoning about property names.
  • Mapped types — type Readonly<T> = { readonly [K in keyof T]: T[K] }. Combined with keyof, the basis for the standard utility types (Partial, Required, Pick, Record) that arrived alongside this release.
  • Object spread and rest at the value level (matching ES2018 syntax).
  • Downlevel async / await for ES3/ES5 targets.
  • Pre-defined utility types: Partial<T>, Required<T>, Pick<T, K>, Record<K, T>.
Version
TypeScript 2.0
Inference
Sep 22, 2016
--strictNullChecks; non-nullable types; control-flow type analysis; never; tagged unions; @types.
  • --strictNullChecks — null and undefined become their own types and are no longer assignable to every other type by default. The single most consequential type-system change in TypeScript's history; reshaped how the entire ecosystem writes nullable values.
  • Control flow type analysis — the compiler tracks variable types through if/else/switch and narrows accordingly. typeof x === "string" guards become first-class.
  • Discriminated (tagged) unions — type Shape = { kind: "circle"; r: number } | { kind: "square"; side: number } with switch (shape.kind) narrowing.
  • The never type — for unreachable code; foundation for exhaustiveness checking.
  • The @types ecosystem — npm scoped packages replace the old typings tool. npm install --save-dev @types/lodash becomes the canonical pattern; DefinitelyTyped becomes the central type-stubs repository.
  • Read-only properties and read-only arrays.

The strictNullChecks break — September 2016. Above this line: the Inference era opened by --strictNullChecks in 2.0, where the type system started to encode runtime safety guarantees the JavaScript spec doesn't. Below: the Pre-2.0 era of the original "JavaScript that scales" pitch — structural typing, declaration files, JSX support, generics — before non-nullability and control-flow analysis reshaped what TypeScript could express.

Version
TypeScript 1.8
Pre-2.0
Feb 22, 2016
--allowJs; string literal types; F-bounded polymorphism.
  • --allowJs — the compiler accepts .js files alongside .ts files. Foundation for incremental TypeScript adoption in existing JS projects.
  • String literal types — type Direction = "left" | "right". Precursor to template literal types in 4.1.
  • F-bounded polymorphism — <T extends Comparable<T>> patterns.
  • Improved JSX support; React stateless functional component typing.
Version
TypeScript 1.7
Pre-2.0
Nov 30, 2015
async/await for ES6 targets; class decorators graduate from experimental.
  • async / await for ES6 targets — the syntax that became one of TypeScript's defining selling points in 2015–2016, when ES6 was still landing in browsers.
  • ES7 exponentiation operator (**).
  • Polymorphic this typing for chainable APIs.
Version
TypeScript 1.6
Pre-2.0
Sep 16, 2015
JSX support; class expressions; intersection types; abstract classes.
  • JSX support — .tsx file extension and the --jsx compiler option. The single biggest reason TypeScript adoption took off in the React community.
  • Intersection types — type AB = A & B.
  • Abstract classes.
  • Class expressions (const Foo = class { ... }).
  • User-defined type guards finalized.
Version
TypeScript 1.5
Pre-2.0
Jul 20, 2015
ES6 modules; experimental decorators; destructuring; let/const.
  • ES6 module syntax — import / export as the canonical module form.
  • Experimental decorators — the @decorator syntax. Enabled by --experimentalDecorators; this is the AtScript-merger-derived shape that Angular 2 was built on. The long road to Stage 3 standardization would not finish until TypeScript 5.0 in 2023.
  • Destructuring (object and array); let and const at the syntactic level.
  • For-of loops; tagged template strings.
  • Computed property names.
Version
TypeScript 1.4
Pre-2.0
Jan 16, 2015
Union types; type aliases; template strings; protected modifier.
  • Union types — string | number. The first appearance of the syntax that has come to define how TypeScript expresses heterogeneous values.
  • Type aliases — type Name = ... as a sanctioned alternative to interface for non-class shapes.
  • Template strings; protected access modifier; let / const.
  • Type guards via typeof and instanceof (the precursor to the full control-flow analysis in 2.0).
Version
TypeScript 1.3
Pre-2.0
Nov 12, 2014
protected access modifier; tuple types.
  • protected access modifier on class members.
  • Tuple types — fixed-length, fixed-type arrays.
Version
TypeScript 1.1
Pre-2.0
Oct 6, 2014
The new compiler — full rewrite, ~4x faster compilation.
  • The new compiler — a complete rewrite of tsc that delivered roughly 4x faster compilation and laid the foundation for the next decade of type-system work. The architectural reset between 1.0 and the modern TypeScript codebase.
  • The 1.1 codebase is the direct ancestor of the codebase Microsoft is now porting to Go (announced March 2025 — see the prose history below).
Version
TypeScript 1.0
Pre-2.0
Apr 2, 2014
First GA release. Declaration merging; better module resolution.
  • First generally-available release — shipped at Microsoft's Build 2014 conference. Marketed as "JavaScript that scales": structural typing, optional static types, classes, modules, generics, transpiles to readable JavaScript.
  • Declaration merging — multiple interface declarations of the same name compose.
  • Better module resolution.
  • Open-sourced under the Apache 2.0 license; developed in the open on GitHub from this point.
Version
TypeScript 0.9
Pre-2.0
Jun 18, 2013
Generics; module-system overhaul.
  • Generics — function map<T, U>(items: T[], f: (x: T) => U): U[]. The single largest type-system feature added in the pre-1.0 phase.
  • Substantial module-system rewrite.
Version
TypeScript 0.8
Pre-2.0
Oct 1, 2012
First public release. Anders Hejlsberg unveils TypeScript at a Microsoft event.
  • First public release of TypeScript — previewed by Anders Hejlsberg at Microsoft on Channel 9 on October 1, 2012. The internal project had been in development since 2010 under the codename "Strada".
  • Already had: classes, modules, interfaces, structural typing, declaration files (.d.ts), the tsc compiler.
  • Initial reception was mixed — the JavaScript community was deeply skeptical of static typing in 2012, and competing efforts (Google's Closure Compiler, Facebook's planned Flow) had different design philosophies.
  • The 0.x line ran for ~18 months as the team worked on generics (0.9) and the new compiler (would land in 1.1).

Click any row to expand. Each row has a stable id for sharing — e.g. /software/typescript/versions/#ts-7-0, #ts-2-0, #ts-0-8. Per-release announcements live on the TypeScript devblog; ship dates and changelogs on github.com/microsoft/TypeScript/releases.

The 2010 internal start and Hejlsberg's design lineage

TypeScript began as an internal Microsoft project in 2010, under the codename "Strada". Anders Hejlsberg — whose previous language designs were Turbo Pascal at Borland (mid-1980s), Delphi at Borland (1995), and C# at Microsoft (2000) — was the chief architect. Steve Lucco, a Microsoft Distinguished Engineer who had previously led the JavaScript engine in Internet Explorer 9 and the Roslyn compiler-platform work, joined as the technical co-lead. The team had a sharp design constraint from the start: TypeScript had to be a strict superset of JavaScript — every valid JS program had to remain a valid TS program — and had to compile to readable JavaScript that ran on every browser.

TypeScript was publicly previewed on October 1, 2012 at a Microsoft event, with Hejlsberg giving the unveiling keynote on Channel 9. Initial reception was mixed: the JavaScript community in 2012 was deeply skeptical of static typing as a Java / C# import. CoffeeScript was the popular JS-with-syntax-extensions of the moment; Google's Closure Compiler had a different design philosophy (annotation comments instead of language extensions); Facebook's planned Flow took yet a third approach. TypeScript's eventual mainstream adoption took most of the 2014–2018 stretch and was not foreordained.

The 2014 1.0 release and the 1.1 compiler rewrite

TypeScript 1.0 shipped at Microsoft Build 2014 (April 2014). Open-sourced under Apache 2.0 license; developed in the open on GitHub. The marketing line — "JavaScript that scales" — framed TypeScript as a tool for projects that had grown past the point where untyped JavaScript was tractable, rather than as a replacement for JavaScript per se. Six months later, TypeScript 1.1 shipped a complete rewrite of the compiler — the original 0.x compiler had been a quick first cut and was being thrown out. The 1.1 codebase was ~4x faster and is the direct ancestor of the codebase Microsoft is now porting to Go (announced March 2025 — see below).

The AtScript merger — Angular 2 and the decorators origin (2014–2015)

In late 2014, Google's Angular team — Miško Hevery, Brad Green, Igor Minar, and others — were designing Angular 2 from scratch and had built their own typed JavaScript dialect called AtScript as a layer on top of TypeScript. AtScript added two things TypeScript didn't have: annotations on declarations (@Component(...) on classes; the syntax that became "decorators") and runtime type information.

At ng-conf 2015 (March 2015), Hevery announced that Angular 2 would adopt TypeScript as its primary authoring language, and that AtScript's syntactic extensions were being merged upstream into TypeScript itself. The decorator syntax shipped in TypeScript 1.5 as --experimentalDecorators; Angular 2 became the first major framework built on TypeScript. The AtScript-derived experimental decorators would remain "experimental but ubiquitous" for the next eight years until TypeScript 5.0 shipped the spec-compliant Stage-3 version in March 2023. The AtScript merger is widely cited as the inflection point for TypeScript's mainstream adoption — a major Google project shipping on TypeScript reset what the JavaScript community thought of as the default.

The strictNullChecks revolution — September 2016

TypeScript 2.0 (September 2016) introduced --strictNullChecks, making null and undefined their own types and removing them from the assignment-everywhere position they'd held since 1.0. Combined with the new control-flow type analysis (the compiler tracks variable types through if/else/switch) and the new tagged-union narrowing pattern, 2.0 reshaped what TypeScript could express. The "billion-dollar mistake" of Tony Hoare's 1965 null-pointer design was finally first-class addressable in a JavaScript type system. Most TypeScript style guides written from late 2016 forward begin with "turn on --strict"; the C#-side ? nullable-reference-types feature would land four years later in C# 8 (September 2019), explicitly modeled on the TypeScript design.

The conditional-types era — March 2018

TypeScript 2.8 (March 2018) shipped conditional types — X extends Y ? A : B — together with the infer keyword for pattern-extracting types out of generics. Conditional types alone were a pleasant addition; conditional types plus distributive behavior over unions plus mapped types (from 2.1) plus recursive conditional types (added in 4.1) turned the type system into a Turing-complete computational language. Modern libraries like Zod, tRPC, Effect, Drizzle, and TypeBox are direct descendants of this expressive shift — they use type-level computation to derive precise typings from values, schemas, or strings.

The template-literal-types era — November 2020

TypeScript 4.1 (November 2020) shipped template literal types, turning string manipulation into a first-class type-system operation: type Greeting = `Hello, ${Name}`. Combined with the conditional-types-plus-infer dialect from 2.8, the type system could now compute precise types from string keys: route("/users/:id") could derive that the handler's params.id is a string. The library ecosystem (Hono, tRPC v10+, Effect, pgTyped, Drizzle ORM) absorbed this expressive level into the modern TypeScript dialect over 2021–2024.

The decorators long road (2015–2026)

Decorators have the most tortured shipping history of any TypeScript feature. They first appeared in TypeScript 1.5 (July 2015) as --experimentalDecorators — the AtScript-derived syntax that Angular 2 was built on. The TC39 standardization track for decorators went through three substantially different proposal iterations between 2014 and 2022: the original "Stage 1" proposal (which TypeScript implemented), a "Stage 2" reset in 2018 that backed away from much of it, and the eventual Stage 3 proposal that finally reached spec-stable in 2022.

TypeScript 5.0 (March 2023) shipped the Stage 3 implementation as the recommended path. The original experimental decorators remain available under --experimentalDecorators for backward compatibility — nearly every Angular and NestJS codebase still uses them — but the new code path is the future. TypeScript 5.2 (August 2023) shipped decorator metadata, completing the runtime-reflection story.

Then the standards track went backwards. On May 19, 2026, TC39 reached consensus to demote decorators from Stage 3 back to Stage 2.7, and moved the companion decorator metadata proposal back alongside it in the same session (meeting notes). The reason was implementation, not design: four years after reaching Stage 3, no JavaScript engine had shipped decorators. SpiderMonkey had a partial implementation it had stopped working on, a V8 contribution surfaced spec bugs and gaps in the Test262 suite, and XS said it had no plans to implement at all. Nothing changes for TypeScript users — tsc still compiles both the standard decorators and the older --experimentalDecorators form down to plain JavaScript — but decorators running natively in an engine moved further away, and the committee explicitly left the door open to dropping to Stage 2 and reopening the design.

Native TypeScript in JavaScript runtimes (2018–)

Deno (Ryan Dahl's post-Node project, launched 2018) was the first major JavaScript runtime to support TypeScript natively — deno run script.ts just works, with the compiler embedded in the runtime. Bun (Jarred Sumner's runtime, 2022 onward) shipped TypeScript support from day one with the compiler integrated into the JIT path. Both runtimes treated TypeScript as a peer of JavaScript rather than as a separate compile-then-run step.

Node.js followed eventually. Node 22.6.0 (August 2024) shipped experimental --experimental-strip-types, treating .ts files as JavaScript with the type annotations stripped at parse time but with no actual type checking. Node 23.6.0 (January 2025) enabled type-stripping by default, backported to Node 22.18.0 (July 2025); Node 24.3.0 (June 2025) dropped the experimental warning. The feature was marked stable in Node 25.2.0 (November 2025) and Node 24.12.0 (December 2025). Node runs only erasable TypeScript syntax — it ignores tsconfig.json, and Node 26.0.0 (May 2026) removed the companion --experimental-transform-types flag that had handled enums, namespaces, and parameter properties, so those now need a third-party loader. The "type stripping" approach — just remove the type annotations and run — had been popularized by esbuild (Evan Wallace's Go-based JS toolchain, 2020) and swc (DongYoon "Donny" Kang's Rust-based equivalent, 2017+); both projects could compile TypeScript ~100x faster than tsc by skipping type checking.

The TC39 type-annotations proposal (active since 2022) is the formal standardization track for "JavaScript engines accept type annotations as comments." Still Stage 1 as of July 2026 — it has not been presented to the committee since September 2023 — so the practical path to running TypeScript syntax without a compile step remains the runtimes' own type-stripping rather than the standard. If it ever advances, it would let TypeScript-syntax files run in browsers directly. For the rest of the TC39 process and the per-edition ECMAScript history that TypeScript's target and lib options track, see the JavaScript version history.

The Go rewrite — from March 2025 announcement to the 7.0 native compiler

On March 11, 2025, the TypeScript team announced that they were porting tsc (the TypeScript compiler) from TypeScript-itself to Go, with a target of roughly 10x faster compilation and TS Server startup. Anders Hejlsberg, in the announcement post, framed the choice of Go as primarily about the language's mature concurrency story (the compiler is heavily parallelizable) and the AOT-compiled startup-time advantage over JavaScript. The new compiler was developed in the open at github.com/microsoft/typescript-go and is the largest architectural change to the TypeScript codebase since the 1.1 compiler rewrite in October 2014.

One year later, on March 23, 2026, TypeScript 6.0 shipped as the final compiler built on the JavaScript codebase. The 6.0 release deliberately resets the defaults that had aged (--strict on, module: esnext, target: ES2025) and adds --stableTypeOrdering as a deliberate-comparison flag for tooling that needs to diff JS-compiler vs. Go-compiler output. The Go-based compiler then moved through a public Beta on April 21, 2026 and a Release Candidate on June 18, 2026.

TypeScript 7.0 shipped stable on July 8, 2026 (published to npm as 7.0.2) — “the native era of the TypeScript toolset,” in the team's own words. Microsoft's benchmarks show 8–12x faster full builds and over 13x faster time-to-first-error in the editor versus 6.0, from a combination of AOT-compiled native code and shared-memory parallel type checking; large adopters (Slack, Vanta, Canva, and Microsoft's own PowerBI, Loop, and News Services teams) reported comparable or larger real-world speedups pre-launch. TypeScript 7.0 does not yet ship a programmatic API — that's targeted for 7.1 — so the typescript npm package now co-exists with a @typescript/typescript6 compatibility package (a tsc6 binary plus a re-exported 6.0 API) for tools like typescript-eslint that need the older API. Nightly builds moved from the standalone @typescript/native-preview package to the standard typescript package's next tag once 7.0 shipped. The release also introduces parallelism controls — --checkers (default 4 type-checking workers), --builders (parallel project-reference builds), and --singleThreaded — plus a rebuilt --watch mode ported from the Parcel file-watcher, and a breaking change to template literal type inference (full Unicode code points instead of UTF-16 surrogate halves). The TypeScript-in-TypeScript codebase stays around as the reference implementation for language semantics, but new feature work and the recommended toolchain have moved to the Go-based compiler; embedding tools (Vue/Volar, MDX, Astro, Svelte, Angular templates) remain on 6.0 until 7.1's API ships. The team expects TypeScript 7.1 on roughly the same 3–4-month cadence as prior releases.

The alternative-toolchain lineage

TypeScript's official compiler (tsc) is the source of truth for type checking, but for compilation-only workloads (transform .ts to .js without type checking), several faster alternative toolchains have eaten significant adoption:

  • esbuild — Evan Wallace's Go-based bundler (2020). The first widely-adopted "TypeScript without tsc" path; ~100x faster than tsc on transform-only workloads. Used by Vite, tsup, and a long tail of bundler tooling.
  • swc — DongYoon "Donny" Kang's Rust-based equivalent (2017 onward, hit mainstream traction with Vercel's adoption in 2021). Used by Next.js, Parcel, and as the rebuild engine for Jest.
  • Bun — Jarred Sumner's Zig-based runtime + bundler + package manager (2022). TS compilation built into the runtime path.
  • tsgo — Microsoft's own typescript-go binary (March 2025), first distributed as @typescript/native-preview and now the tsc that ships in TypeScript 7.0. The first first-party "fast tsc" coming directly from the TypeScript team — and, unlike the others on this list, a full type checker rather than a transform-only tool.
  • Oxc — Boshen's Rust-based JS / TS toolchain (2023+), now under VoidZero alongside Rolldown; positioning itself as the next-generation linter / formatter / type-stripper.

People who actually shaped TypeScript

Microsoft TypeScript team: Anders Hejlsberg (Technical Fellow, chief architect; previously Turbo Pascal at Borland in the 1980s, Delphi at Borland in 1995, C# at Microsoft from 2000), Steve Lucco (Distinguished Engineer, technical co-lead; previously the IE9 JavaScript engine and Roslyn compiler platform), Daniel Rosenwasser (Senior Program Manager and the public-facing voice of TS releases since the 2.x line), Ryan Cavanaugh (engineering manager since the early years), Mohamed Hegazy (long-time language-services engineer), Andrew Branch (module-resolution and Node-ESM work), Wesley Wigham (decorators and the Stage-3 implementation), Nathan Shively-Sanders (control flow analysis), Sheetal Nandi (compiler internals), Bill Ticehurst, Jakub Wojciechowski, and the long tail of the TS team contributors.

AtScript / Angular lineage: Miško Hevery (Angular co-creator, AtScript design, ng-conf 2015 keynote announcing the merger), Brad Green (Angular team lead at Google), Igor Minar (Angular long-time PM), Jonathan Turner (early TypeScript PM who handled the AtScript-merger negotiations on the Microsoft side; later joined the Rust team).

Type-driven library lineage: Colin McDonnell (Zod author), Alex Johansson and Julius Marminge (tRPC), Michael Arnaldi (Effect-TS), Andrew Sherman and Alex Blokh (Drizzle ORM), Haydn Paterson (TypeBox). These authors collectively shaped how the conditional-types-plus-template-literal-types dialect is used in production. Alternative-toolchain lineage: Evan Wallace (esbuild), DongYoon "Donny" Kang (swc), Jarred Sumner (Bun), Boshen (Oxc).

Find your version — in the terminal

The browser cannot detect what version of TypeScript is installed on your machine — there's no UA Client Hint or fingerprint that exposes it. Run one of these in your terminal to see your real install.

What's installed?

Most projects have two TypeScripts: a globally-installed one and a project-local one in node_modules. The project-local one is almost always what your editor and build use.

$ tsc --version                   # global install (if any)
$ npx tsc --version               # the project-local install (./node_modules/.bin/tsc)
$ npm ls typescript                  # every typescript in your dep tree, with paths
$ cat package.json | grep typescript # pinned version in package.json
$ which tsc                          # where the global tsc binary lives

Pin a project to a specific TypeScript

TypeScript is a regular npm package; pin it in devDependencies. The exact-version "7.0.2" form (no ^ prefix) is conventional because TypeScript point releases sometimes change type-checking behavior.

// package.json
{
  "devDependencies": {
    "typescript": "7.0.2"           // exact-pin convention
  },
  "engines": {
    "node": ">=20"                  // optional: pin Node too
  }
}

For tool-version-managing the whole shell environment, see volta, corepack, asdf, or mise.

Install or upgrade a version

Always install TypeScript as a project devDependency, not globally; that way every contributor uses the same compiler.

$ npm install --save-dev typescript@latest    # latest stable (currently 7.0.x, the Go-native compiler)
$ npm install --save-dev typescript@5.9         # a specific minor (5.9 was the last 5.x)
$ npm install --save-dev typescript@rc           # the in-development release candidate for the next minor
$ npm install --save-dev typescript@beta         # the in-development pre-release
$ npm install --save-dev typescript@next         # nightly builds (moved here from @typescript/native-preview at 7.0 GA)

# pnpm and yarn equivalents:
$ pnpm add -D typescript@latest
$ yarn add -D typescript@latest

# Bun's built-in TS support uses its bundled tsc, but you can still install one:
$ bun add -d typescript@latest

# Need 6.0's API alongside 7.0's tsc (e.g. for typescript-eslint)? Install the
# compatibility package, which ships a separate "tsc6" binary:
$ npm install --save-dev @typescript/typescript6

Tell VS Code which TypeScript to use

VS Code ships its own bundled TypeScript for editor IntelliSense, which is usually behind your project's. The "TypeScript: Select TypeScript Version" command lets you switch the active TS Server to the one in your node_modules.

# Command Palette (Cmd-Shift-P / Ctrl-Shift-P):
→ TypeScript: Select TypeScript Version
   # pick: "Use Workspace Version" → ./node_modules/typescript

# Or hard-code the workspace setting:
// .vscode/settings.json
{
  "typescript.tsdk": "node_modules/typescript/lib",
  "typescript.enablePromptUseWorkspaceTsdk": true
}

# Verify which version is active: bottom-right status bar shows
# "TypeScript X.Y.Z" — click it to confirm the path.

Sources: TypeScript devblog; microsoft/TypeScript releases; TypeScript handbook; handbook release notes; Anders Hejlsberg's October 2012 unveiling; the March 2025 Go-rewrite announcement; Miško Hevery's ng-conf 2015 keynote; the July 2026 TypeScript 7.0 GA announcement; and contemporaneous reporting cited inline. Last updated July 2026.

Mungomash LLC · More data pages