Microsoft annonce la version Release Candidate de TypeScript 7.0, basée sur le langage Go, permettant d'exécuter de nombreuses étapes en parallèle

Notamment l'analyse syntaxique et la vérification des types

Microsoft annonce la version Release Candidate de TypeScript 7.0, basée sur le langage Go, permettant d'exécuter de nombreuses étapes en parallèle, notamment l'analyse syntaxique et la vérification des types

Microsoft annonce la sortie de la version Release Candidate de TypeScript 7.0. La nouvelle base de code Go a été méthodiquement portée à partir de l'implémentation existante plutôt que réécrite à partir de zéro, et sa logique de vérification des types est structurellement identique à celle de TypeScript 6.0. Même si la version 7.0 RC est presque prête pour la production, ils ne disposeront pas d’une API programmatique stable avant au moins plusieurs mois, avec la sortie de TypeScript 7.1. Dans ce contexte, l'équipe TypeScript donne la priorité à la garantie que TypeScript puisse fonctionner en parallèle avec TypeScript 6.0 dans un avenir proche.

TypeScript (TS) est un langage de programmation de haut niveau qui ajoute à JavaScript un typage statique avec des annotations de type facultatives. Il est conçu pour le développement d'applications volumineuses et est compilé en JavaScript. TypeScript est développé par Microsoft en tant que logiciel libre et open source, distribué sous licence Apache 2.0. En mars 2025, Microsoft a annoncé que son équipe travaillait sur une version du compilateur TypeScript portée sur Go, qui devrait être publiée sous le nom de TypeScript 7.0. En décembre de la même année, il a été annoncé sur le blog de l'entreprise que TypeScript 6.0 serait la dernière version écrite en TypeScript lui-même, et que TypeScript 7.0 serait la première version basée sur Go.

En avril 2026, Microsoft a annoncé la sortie de TypeScript 7.0 Beta, marquant ainsi le lancement de la version bêta publique de la refonte, basée sur Go, du compilateur et de la suite d'outils du langage. Cette version est présentée comme un changement architectural majeur pour le langage, Microsoft affirmant que la nouvelle implémentation est « environ dix fois plus rapide que TypeScript 6.0 ». Bien qu'il s'agisse d'une version bêta, l'entreprise affirme que le compilateur est prêt pour la production. TypeScript 7.0 Beta est entièrement compatible avec TypeScript 6.0 et apporte plusieurs nouveautés visant à améliorer ses performances, sa stabilité et sa compatibilité. Grâce à la combinaison de la vitesse du code natif et du parallélisme en mémoire partagée, TypeScript 7.0 est souvent environ 10 fois plus rapide que TypeScript 6.0.

Récemment, Microsoft annonce la sortie de la version Release Candidate de TypeScript 7.0. La nouvelle base de code Go a été méthodiquement portée à partir de l'implémentation existante plutôt que réécrite à partir de zéro, et sa logique de vérification des types est structurellement identique à celle de TypeScript 6.0. Cette parité architecturale garantit que le compilateur continue d’appliquer exactement la même sémantique à laquelle vous êtes déjà habitué. TypeScript 7.0 a été évalué à l’aide de l’énorme suite de tests constituée au cours de la dernière décennie, et est déjà utilisé dans de nombreuses bases de code comptant plusieurs millions de lignes, tant au sein de Microsoft qu’à l’extérieur. Il est stable, compatible et prêt à être mis à l’épreuve dès dans vos workflows quotidiens et vos pipelines d’intégration continue.

Depuis plus d’un an, l'équipe TypeScript collabore avec de nombreuses équipes internes de Microsoft, ainsi qu’avec des équipes d’entreprises telles que Bloomberg, Canva, Figma, Google, Lattice, Linear, Miro, Notion, Slack, Vanta, Vercel, VoidZero et bien d’autres, afin de tester les versions préliminaires de TypeScript 7.0 sur leurs bases de code. Les retours ont été positifs : de nombreuses équipes ont signalé des gains de vitesse similaires, réduisant considérablement leurs temps de compilation, et ont bénéficié d’une expérience d’édition beaucoup plus légère et fluide.

Utilisation de TypeScript 7.0 RC

Pour obtenir TypeScript 7.0 RC, vous pouvez l’installer via npm :



À partir de là, vous pouvez exécuter tsc comme avec n’importe quelle version précédente de TypeScript, et vous devriez obtenir les mêmes résultats qu’auparavant – mais beaucoup plus rapidement !



Pour tester l’expérience d’édition, vous pouvez installer l’extension TypeScript Native Preview pour VS Code. La prise en charge par l’éditeur est extrêmement fiable et est largement utilisée par de nombreuses équipes depuis plusieurs mois déjà. C’est un moyen simple et fluide de tester immédiatement TypeScript 7.0 sur votre base de code. Elle repose sur les mêmes fondements que l’expérience en ligne de commande, vous bénéficiez donc des mêmes gains de performances dans votre éditeur que sur la ligne de commande. Il est notamment important de noter qu’elle s’appuie sur le protocole LSP (Language Server Protocol), ce qui facilite son exécution dans la plupart des éditeurs modernes, voire dans des outils tels que Copilot CLI.

Utilisation en parallèle avec TypeScript 6.0

Même si la version 7.0 RC est presque prête pour la production, ils ne disposeront pas d’une API programmatique stable avant au moins plusieurs mois, avec la sortie de TypeScript 7.1. Dans ce contexte, l'équipe TypeScript donne la priorité à la garantie que TypeScript puisse fonctionner en parallèle avec TypeScript 6.0 dans un avenir proche, sans aucun conflit du type « quel tsc est lequel ? ».

Dans le cadre du processus de transition entre les versions 6.0 et 7.0, ils ont publié un nouveau package de compatibilité, @typescript/typescript6. Ce package fournit un exécutable nommé tsc6, afin que, si nécessaire, vous puissiez installer TypeScript 7.0 (qui intègre son propre binaire tsc) en parallèle sans conflit de noms. Le nouveau paquet réexporte également l’API de TypeScript 6.0, ce qui vous permet d’utiliser tsc pour TypeScript 7, tandis que d’autres outils peuvent continuer à s’appuyer sur la version 6.0.

Étant donné que certains outils, tels que typescript-eslint, s’attendent à importer directement depuis TypeScript via des dépendances de pair, il est recommandé d’utiliser des alias npm. Vous devriez pouvoir exécuter la commande suivante :



ou modifier votre fichier package.json comme suit :



Notez que cette procédure ne vous laissera qu’un exécutable tsc6. Pour obtenir le tsc de la version 7.0, vous pouvez ajouter un autre alias pour TypeScript 7 ; npx tsc fonctionnera alors directement avec la version 7.0 :



Versions « nightly »

Les versions « nightly » de TypeScript 7 sont actuellement toujours publiées sous le paquet @typescript/native-preview sur npm, et peuvent être installées via



Le binaire fourni par ce paquet s’appelle toujours tsgo. Une fois que TypeScript 7 aura été publié avec la dernière balise sur npm, ils prévoient que toutes les versions stables, les préversions majeures et les versions « nightly » seront publiées sous le paquet typescript sur npm.


Voici les principales améliorations présentées par l'équipe de TypeScript :

Parallélisation et contrôles

TypeScript 7.0 exécute désormais de nombreuses étapes en parallèle, notamment l’analyse syntaxique, la vérification des types et la génération de code. Certaines de ces étapes, comme l’analyse syntaxique et la génération de code, peuvent généralement être effectuées de manière indépendante d’un fichier à l’autre. Ainsi, la parallélisation s’adapte automatiquement aux bases de code plus volumineuses avec une surcharge relativement faible. Cependant, toutes les étapes d’une compilation TypeScript ne se prêtent pas facilement à la parallélisation.

Parallélisation des vérificateurs

D’autres étapes, comme la vérification des types, présentent des dépendances plus complexes entre les fichiers. La plupart des fichiers finissent par s’appuyer sur les mêmes informations de type provenant de leurs dépendances et de la portée globale ; par conséquent, exécuter les vérificateurs de types de manière totalement indépendante serait un gaspillage, tant en termes de calcul que de mémoire. D’autre part, la vérification des types s’appuie parfois sur l’ordre relatif des informations dans un programme ; ainsi, une vérification des types effectuée à partir de zéro doit toujours analyser les mêmes fichiers dans un ordre identique pour garantir des résultats identiques.

Pour permettre la parallélisation tout en évitant ces écueils, TypeScript 7.0 crée un nombre fixe de « workers » de vérification de types, chacun disposant de sa propre vision du monde. Ces « workers » de vérification de types peuvent finir par dupliquer certaines tâches communes, mais, à partir des mêmes fichiers d’entrée, ils les répartiront toujours de manière identique et produiront les mêmes résultats.

Le nombre par défaut de processus de vérification de types est de 4, mais il peut être configuré à l’aide du nouvel indicateur --checkers. Vous constaterez peut-être qu’augmenter ce nombre peut accélérer davantage les compilations sur des bases de code plus volumineuses, où les machines disposent généralement de plus de cœurs de processeur, mais cela se fera généralement au prix d’une utilisation accrue de la mémoire. De même, les machines disposant de moins de cœurs de processeur et de moins de mémoire (par exemple, les exécuteurs d’intégration continue) peuvent avoir intérêt à réduire ce nombre pour éviter une surcharge inutile ou accidentelle.

Dans de rares cas, la variation du nombre de --checkers peut faire apparaître des résultats dépendants de l’ordre d’exécution. Spécifier un nombre fixe de vérificateurs dans tous les environnements de compilation peut aider à garantir que tout le monde obtient les mêmes résultats, mais cela reste à la discrétion de chaque équipe.

Parallélisation des générateurs de référence de projet

TypeScript 7.0 permet de paralléliser les compilations au sein d’un même projet, mais il peut désormais également compiler plusieurs projets simultanément. Ce comportement peut être configuré à l’aide du nouvel indicateur --builders, qui contrôle le nombre de générateurs de référence de projet parallèles pouvant s’exécuter simultanément. Cela peut s’avérer particulièrement utile pour les monorepos contenant de nombreux projets.

Tout comme avec --checkers, augmenter le nombre de générateurs peut accélérer les compilations, mais peut se faire au prix d’une consommation de mémoire accrue. Cela a également un effet multiplicateur avec --checkers ; il est donc important de trouver le bon équilibre pour votre machine et votre base de code. Par exemple, une compilation avec --checkers 4 --builders 4 permet à jusqu’à 16 vérificateurs de types de s’exécuter simultanément, ce qui peut s’avérer excessif.

Contrairement à --checkers, la variation du nombre de générateurs ne devrait pas produire de résultats différents ; cependant, la compilation des références de projet est fondamentalement limitée par le graphe de dépendances des projets (à l’exception de la vérification de types sur les bases de code qui exploitent --isolatedDeclarations et génèrent un fichier de déclaration syntaxique séparé).

Mode mono-thread

Dans certains cas, il peut être utile d’imposer un fonctionnement mono-thread à l’ensemble du compilateur. Cela peut s’avérer utile pour le débogage, pour comparer les performances entre TypeScript 6 et 7, lors de l’orchestration externe de compilations parallèles, ou pour l’exécution dans des environnements aux ressources très limitées. Pour activer le mode mono-thread, vous pouvez utiliser le nouvel indicateur --singleThreaded. Cela limitera non seulement le nombre de workers de vérification de types à 1, mais garantira également que l’analyse syntaxique et la génération de fichiers s’effectuent dans un seul thread.

Mode --watch amélioré

Il convient de souligner la refonte du mode --watch dans TypeScript 7. Le mode --watch repose désormais sur une nouvelle base dérivée du système de surveillance de fichiers du bundler Parcel, qui offre des capacités de surveillance de fichiers multiplateformes efficaces et stables.

Lorsque notre équipe s’est attelée à porter notre logique de surveillance de fichiers, nous avons rencontré quelques difficultés liées à la surveillance multiplateforme en Go. La bibliothèque standard ne fournit pas d’API intégrée de surveillance des fichiers, et les bibliothèques tierces existantes que nous avons explorées présentaient divers problèmes de stabilité, de performances, de prise en charge multiplateforme ou d’intégration avec les outils de build. Nous avons pu mettre au point des solutions reposant sur des interrogations périodiques pour détecter les modifications de fichiers, ce qui fonctionnait globalement sur tous les systèmes d’exploitation ; cependant, cela s’avérait très gourmand en ressources, en particulier pour les projets à grande échelle comportant de nombreuses dépendances dans node_modules. Même avec des stratégies de planification dynamiques, nous avons constaté que les solutions basées uniquement sur l’interrogation étaient trop gourmandes en ressources pour une utilisation courante.

Depuis de nombreuses années, Visual Studio Code s’appuie sur @parcel/watcher, et ces dernières années, TypeScript dans VS Code a indirectement tiré parti de ses capacités de surveillance de fichiers. Bien que cela semblait prometteur, l’un des problèmes que nous rencontrions avec le watcher de Parcel est qu’il est écrit en C++ et nécessite donc une chaîne d’outils C++ complète pour sa compilation. Compte tenu de notre expérience positive avec le watcher de Parcel dans VS Code, nous avons exploré la possibilité de le porter en Go à l’aide de quelques shims d’assemblage minimaux afin d’éviter d’introduire une nouvelle dépendance à une chaîne d’outils.

Cette exploration a été couronnée de succès : ce qui avait commencé comme une traduction très directe du C++ vers Go a été affiné pour devenir un code idiomatique en Go qui continue de passer avec succès la suite de tests portée. Le « watcher » est un paquet autonome qui nous a permis de maintenir une séparation claire des préoccupations entre ce que nous souhaitons surveiller et pourquoi. Nous constatons désormais des améliorations significatives en termes de ressources en mode --watch sur toutes les plateformes, et avons reçu des retours positifs de la part des premiers utilisateurs de TypeScript 7.

Nous tenons à remercier Devon Govett, dont le travail sur Parcel a apporté d’immenses avantages tant au projet Visual Studio Code qu’à celui de TypeScript. Nous espérons que ce portage offrira, à terme, de nouvelles opportunités et des perspectives pour le code source original du « watcher » de Parcel.

Mises à jour depuis la version 5.x et nouveaux comportements à partir de la version 6.0

TypeScript 7.0 est conçu pour être compatible avec la vérification des types et le comportement en ligne de commande de TypeScript 6.0. Pratiquement tout code TypeScript qui se compile sans erreur avec TypeScript 6.0 (avec le drapeau stableTypeOrdering activé et sans aucun drapeau ignoreDeprecations défini) devrait se compiler de la même manière dans TypeScript 7.0.

Cela dit, TypeScript 7.0 adopte les nouvelles valeurs par défaut de la version 6.0 et génère des erreurs fatales en cas d’utilisation de drapeaux ou de constructions obsolètes dans TypeScript 6.0. Ce point est important, car la version 6.0 est encore relativement récente et de nombreux projets devront s’adapter à ses nouveaux comportements. Nous encourageons les développeurs à adopter TypeScript 6.0 afin de faciliter la transition vers TypeScript 7.0. Vous pouvez également consulter l’article de blog consacré à la sortie de TypeScript 6.0 pour plus de détails sur ces dépréciations.

En bref, les changements notables apportés aux paramètres par défaut sont les suivants :

- strict est défini sur true par défaut.
- module est défini par défaut sur esnext.
- target est défini par défaut sur la version stable actuelle d’ECMAScript précédant immédiatement esnext.
- noUncheckedSideEffectImports est défini sur true par défaut.
- libReplacement est défini sur false par défaut.
- stableTypeOrdering est défini sur true par défaut et ne peut pas être désactivé.
- rootDir est désormais défini par défaut sur ./, et les répertoires source internes doivent être explicitement définis.
- types est désormais défini par défaut sur [], et l’ancien comportement peut être rétabli en le définissant sur ["*"].

Nous pensons que les modifications apportées à rootDir et types sont peut-être les plus « surprenantes », mais elles peuvent être facilement gérées. Les projets dans lesquels le fichier tsconfig.json se trouve en dehors d’un répertoire tel que src devront simplement inclure rootDir pour conserver la même structure de répertoires.



En ce qui concerne la modification de types, les projets qui dépendent de déclarations globales spécifiques devront les énumérer explicitement. Par exemple :



Les éléments obsolètes qui sont désormais considérés comme des erreurs graves sans conséquence sont les suivants :

- target : es5 n'est plus pris en charge.
- downlevelIteration n'est plus pris en charge.
- moduleResolution : node/node10 ne sont plus pris en charge ; il est recommandé d'utiliser nodenext et bundler à la place.
- module : amd, umd, systemjs, none ne sont plus pris en charge ; il est recommandé d’utiliser esnext ou preserve en association avec des bundlers ou la résolution de modules basée sur le navigateur.
- baseUrl n’est plus pris en charge, et les paths peuvent être mis à jour pour être relatifs à la racine du projet plutôt qu’à baseUrl.
- moduleResolution : classic n’est plus pris en charge ; il est recommandé de le remplacer par bundler ou nodenext.
- esModuleInterop et allowSyntheticDefaultImports ne peuvent pas être définis sur false.
- alwaysStrict est considéré comme true et ne peut plus être défini sur false.
- Le mot-clé module ne peut pas être utilisé dans les déclarations d’espace de noms.
- Le mot-clé asserts ne peut pas être utilisé sur les importations ; il faut utiliser à la place le mot-clé with (afin de s’aligner sur les évolutions de la syntaxe de l’attribut import d’ECMAScript).
- Les directives /// <reference no-default-lib /> ne sont plus respectées lorsque skipDefaultLibCheck est activé.
- Les compilations en ligne de commande ne peuvent pas prendre en compte les chemins d’accès aux fichiers lorsque le répertoire courant contient un fichier tsconfig.json, sauf si le drapeau explicite --ignoreConfig est passé.

Les types de littéraux de modèle préservent désormais les points de code Unicode

TypeScript 7.0 traite désormais les points de code Unicode de manière plus naturelle lors de l’inférence à partir des types de littéraux de modèle. Par exemple :



Auparavant, TypeScript suivait ici le comportement d’indexation UTF-16 de JavaScript et divisait "😀" en deux moitiés formant une paire de substituts (\ud83d et \ude00). Cela était techniquement cohérent avec l’indexation en JavaScript (par exemple, le type Head déduit était égal à " 😀abc"[0]), mais ce n’était généralement pas ce que les utilisateurs souhaitaient, et cela pouvait produire des types de littéraux de chaîne contenant des caractères de substitution non appariés qui n’ont pas de sens sémantique.

Il s’agit d’un changement rompant pour la manipulation de chaînes au niveau des types qui modélisait intentionnellement les unités de code UTF-16, comme certaines utilitaires de longueur de chaîne. En pratique, nous nous attendons à ce que ce nouveau comportement soit plus utile et moins surprenant : l’inférence des littéraux de modèle suit désormais la même intuition que l’itération d’une chaîne avec for...of ou son étalement avec [...str], où "😀" est traité comme une seule unité.

Différences par rapport à JavaScript

Lors du portage de la base de code existante, nous en avons également profité pour revoir le fonctionnement de notre prise en charge de JavaScript.

À l’origine, TypeScript prenait en charge les fichiers JavaScript en utilisant les commentaires JSDoc et en reconnaissant certains modèles de code pour l’analyse et l’inférence de types. La plupart du temps, cela reposait sur des modèles de codage courants, mais parfois, cela reposait sur tout ce que les développeurs pouvaient écrire et que Closure et l’outil de génération de documentation JSDoc étaient capables de comprendre. Bien que cette approche ait été utile pour les développeurs disposant de bases de code JSDoc rédigées de manière peu rigoureuse, elle nécessitait un certain nombre de compromis et de cas particuliers pour fonctionner correctement, et s’écartait à plusieurs égards de l’analyse effectuée par TypeScript dans les fichiers .ts.

Dans TypeScript 7.0, nous avons remanié notre prise en charge de JavaScript afin qu’elle soit plus cohérente avec la manière dont nous analysons les fichiers TypeScript. Voici quelques-unes des différences :

- Les valeurs ne peuvent pas être utilisées là où des types sont attendus – écrivez plutôt typeof someValue.
- @enum n’est plus reconnu spécifiquement – créez un @typedef sur (typeof YourEnumDeclaration)[keyof typeof YourEnumDeclaration].
- Un ? isolé n’est plus utilisable comme type – utilisez plutôt any.
- @class ne transforme pas une fonction en constructeur – utilisez plutôt une déclaration de classe.
- Le suffixe ! n’est pas pris en charge – utilisez simplement T.
- Les noms de types doivent être définis à l’intérieur d’une balise @typedef (par exemple : /** @typedef {T} TypeAliasName */), et non à côté d’un identifiant (par exemple : /** @typedef {T} */ TypeAliasName;).
- La syntaxe des fonctions de type « closure » (par exemple function(string): void) n’est plus prise en charge – utilisez plutôt les raccourcis TypeScript (par exemple (s: string) => void).

De plus, certains modèles JavaScript, comme l’aliasing de this et la réaffectation de l’intégralité du prototype d’une fonction, ne font plus l’objet d’un traitement particulier.

Bien qu’une partie de notre prise en charge de JS soit en pleine évolution, nous avons mis à jour ce fichier CHANGES.md afin de détailler plus précisément les différences entre TypeScript 6.0 et 7.0.

Expérience dans l’éditeur

Les améliorations de performances de TypeScript 7.0 ne se limitent pas à l’utilisation en ligne de commande : elles s’étendent également à l’expérience dans l’éditeur. Pour les utilisateurs de VS Code, l’extension « TypeScript Native Preview » offre un moyen simple d’essayer TypeScript 7.0 dans votre éditeur, et elle est désormais largement utilisée. Pour les utilisateurs de Visual Studio, la dernière version de l’éditeur activera automatiquement TypeScript 7 en fonction de votre espace de travail. Bien entendu, TypeScript 7 devrait fonctionner parfaitement dans n’importe quel éditeur de votre choix. La nouvelle infrastructure repose sur le protocole LSP (Language Server Protocol) et est capable d’exploiter plusieurs threads pour traiter les requêtes simultanées aussi rapidement que possible.

Depuis son lancement, nous avons ajouté des fonctionnalités qui manquaient, telles que les importations automatiques, les survols extensibles, les astuces intégrées, les « code lenses », la fonction « aller à la définition source », l’édition liée à JSX et la complétion des balises, entre autres. Les fonctionnalités manquantes de la version bêta de TypeScript 7.0, telles que la mise en évidence sémantique, le « tri des importations », la « suppression des importations inutilisées », et bien d’autres encore, sont désormais disponibles.

De plus, nous avons continué à améliorer les performances et la stabilité au cours des derniers mois. Nous avons refondu une grande partie de notre infrastructure de tests et de diagnostics afin de garantir un niveau de qualité élevé, ce qui nous permet de soumettre le serveur de langage à des tests de fuzz sur les principales bases de code TypeScript et JavaScript disponibles sur GitHub. D’après nos analyses de données, nous estimons que TypeScript 7 a en réalité réduit de plus de 20 fois le nombre d’échecs des commandes du serveur de langage par rapport à TypeScript 6.0.

Cette extension respecte la plupart des paramètres de configuration de l’extension TypeScript intégrée à Visual Studio Code, ainsi que la plupart de ses fonctionnalités.

Source : Annonce TypeScript 7.0 RC

Et vous ?

Pensez-vous que cette version est crédible ou pertinente ?
Quel est votre avis sur le sujet ?

Voir aussi :

Microsoft annonce TypeScript 6.0 apportant des améliorations aux fonctions sensibles au contexte, la prise en charge des importations de sous-chemins et des changements pour préparer TypeScript 7.0

Un TypeScript 10x plus rapide : Anders Hejlsberg, architecte principal de Microsoft pour TypeScript, présente un nouveau portage de TypeScript, qui offrira aux développeurs un outil de haute performance

TypeScript se tourne vers Gopher : Microsoft mise sur Go pour multiplier la vitesse par 10, par Kush Creates