Mungomash LLC
TypeScript Versions

2012 – 2026

TypeScript Versions

Every public release of TypeScript — from TypeScript 0.8 in October 2012 through TypeScript 6.0 in March 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 landed as the foundation of TypeScript 7.0.

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 6.0
Modern
Mar 23, 2026
Latest release. The final JavaScript-codebase compiler before the 7.0 Go-native port. --strict on by default; module defaults to esnext; target defaults to ES2025.
  • The final JavaScript-codebase release of TypeScript — clears the deck for the Go-native 7.0, available now in nightly preview as @typescript/native-preview. 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 defaults to ES2025 (was ES5 for a decade); the legacy default-set that newcomers stumbled over is finally retired.
  • --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
Mar 4, 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 tools like Bun and Astral's downstream toolchain.
  • 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 (TC39 Stage 3). Calls Symbol.dispose/Symbol.asyncDispose at the end of the enclosing scope. Python's with / C#'s using finally arrives in JavaScript.
  • 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.
  • 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. /data/typescript/versions/#ts-6-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 Astral's 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, Astral's pgTyped, Drizzle ORM) absorbed this expressive level into the modern TypeScript dialect over 2021–2024.

The decorators long road (2015–2023)

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.

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 (April 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 (October 2024) made type-stripping the default for .ts files. 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 (Donny Wong'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." Stage 1 as of the table's last update; if it advances, it would let TypeScript-syntax files run in browsers without any compile step.

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 ships as the foundation of TypeScript 7.0, currently in nightly preview as the @typescript/native-preview npm package and as a VS Code extension. As of the table's last update, 7.0 is targeted for stable release within months and is reportedly already in production at large codebases inside and outside Microsoft. The TypeScript-in-TypeScript codebase stays around as the reference implementation for language semantics, but new feature work and the recommended toolchain are moving to the Go-based compiler.

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 — Donny Wong'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.
  • Astral's tsgo / Microsoft's typescript-go — the official Go port (March 2025). The first first-party "fast tsc" coming directly from the TypeScript team.
  • Oxc — Boshen Chen's Rust-based JS / TS toolchain (2023+); 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 (Drizzle ORM), Sergey Berezhnoy (TypeBox). These authors collectively shaped how the conditional-types-plus-template-literal-types dialect is used in production. Alternative-toolchain lineage: Evan Wallace (esbuild), Donny Wong (swc), Jarred Sumner (Bun), Boshen Chen (Oxc), Charlie Marsh (Astral — ruff / uv / and the TypeScript Native Preview / tsgo collaboration with Microsoft).

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 "5.7.2" form (no ^ prefix) is conventional because TypeScript point releases sometimes change type-checking behavior.

// package.json
{
  "devDependencies": {
    "typescript": "5.7.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 6.0.x)
$ npm install --save-dev typescript@5.9         # a specific minor (5.9 is the last 5.x)
$ npm install --save-dev typescript@beta         # the in-development pre-release
$ npm install --save-dev typescript@next         # the nightly

# 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

# Try the Go-native compiler (TS 7.0 nightly preview):
$ npm install --save-dev @typescript/native-preview

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; and contemporaneous reporting cited inline. Last updated April 2026.

Mungomash LLC · More data pages