Сборка в 10 раз быстрее: что на самом деле меняет нативный TypeScript 7
TypeScript 7 ускорил компиляцию в 10 раз, но ваше приложение не станет быстрее. Что реально изменилось в нативном компиляторе на Go
Все уже слышали, что TypeScript «стал нативным». И по кругу ходит один и тот же неверный вывод: что приложения на TypeScript теперь будут работать быстрее, или что JavaScript заменяют, или что командам нужно что-то переписывать. Ничего из этого не так. То, что произошло на самом деле, — уже, и для большинства бизнесов полезнее: Microsoft переписала компилятор и тулчейн TypeScript на Go, и результат — анонсированный Андерсом Хейлсбергом, изначальным архитектором языка, — это примерно 10-кратное ускорение проверки типов и сборки.
Проще говоря: код вашего продукта не меняется и быстрее не становится. Драматически быстрее становится механизм, который этот код проверяет и собирает. Именно это различие решает, стоит ли новость бюджета и времени на планирование, — так что давайте разберём её как следует.
Что на самом деле значит «стал нативным»
В TypeScript всегда было две части:
- Язык — синтаксис, система типов, правила, по которым пишут ваши разработчики.
- Компилятор и тулинг — программа (
tsc), которая проверяет эти типы, плюс language service, на котором работают автодополнение и подчёркивание ошибок в редакторе.
Больше десяти лет часть 2 сама была написана на TypeScript и исполнялась на Node.js. Исторически это был разумный выбор, но JavaScript-рантаймы несут структурные накладные расходы для такого рода нагрузки: отсутствие параллелизма с общей памятью в ядре компилятора, прогрев JIT и высокое давление на аллокатор. «Нативный порт» — внутреннее имя Corsa, опубликован как typescript-go — это переписывание той самой второй части на Go, с компиляцией в нативный бинарник, использующий все ядра вашего CPU.
Бытовая аналогия: чертежи архитектора для вашего здания идентичны до последней линии. Изменилось чертёжное бюро — оно перешло с ручного черчения на CAD. То же здание, те же несущие стены, тот же результат. Просто чертежи приходят в десять раз быстрее.
Из этого следует и нейминг: текущая линия компилятора на JavaScript продолжается как TypeScript 6.x, а нативный компилятор выйдет как TypeScript 7, когда достигнет паритета. Обе линии держат согласованными по поведению языка — именно для того, чтобы «апгрейд» был заменой тулчейна, а не проектом миграции.
Реальные цифры: как выглядит 10x на реальных кодовых базах
Это опубликованные Microsoft бенчмарки из анонса, снятые на известных open-source-проектах — не синтетические тесты:
| Кодовая база | Размер | Старый компилятор | Нативный компилятор | Ускорение |
|---|---|---|---|---|
| VS Code | 1 505 000 строк | 77,8 с | 7,5 с | 10,4x |
| Playwright | 356 000 строк | 11,1 с | 1,1 с | 10,1x |
| TypeORM | 270 000 строк | 17,5 с | 1,3 с | 13,5x |
| date-fns | 104 000 строк | 6,5 с | 0,7 с | 9,5x |
| tRPC | 18 000 строк | 5,5 с | 0,6 с | 9,1x |
Ещё две цифры значат не меньше, чем чистое время компиляции. Загрузка проекта в редакторе на кодовой базе VS Code упала примерно с 9,6 секунды до 1,2 секунды — примерно 8x — а это разница между «открыл репозиторий и ждёшь» и «открыл репозиторий и печатаешь». А потребление памяти составляет примерно половину от текущего компилятора — именно это решает, умрёт ли проверка типов большого монорепозитория с ошибкой out-of-memory на вашем CI-раннере.
Честно говоря: если ваша кодовая база сегодня проверяется за четыре секунды, вы этого не почувствуете. Выигрыш растёт с размером проекта. Беспокоиться стоит тем командам, у которых tsc занимает 30+ секунд, редактор тормозит на автодополнении или монорепозиторию нужны специальные флаги памяти, чтобы вообще пройти проверку. Под это описание попадает множество продуктов старше второго года разработки.
Что это значит для вашего DevOps-пайплайна
Если вы задаётесь вопросом, при чём тут DevOps-пайплайн и переписанный компилятор — при всём, потому что проверка типов стоит на критическом пути почти каждого из них. Типичный пайплайн запускается на каждый коммит: установка зависимостей, проверка типов, линт, тесты, сборка, деплой. На средних TypeScript-продуктах шаг проверки типов регулярно оказывается одним из самых медленных ворот ещё до старта тестов.
Бизнес-арифметика проста. Возьмём команду из шести разработчиков с 30 запусками пайплайна в день, где проверка типов съедает 3 минуты на запуск. Это 90 минут пайплайна ежедневно на один шаг. Урежьте его в 10 раз — и вы вернёте больше 80 минут CI-времени каждый день, что напрямую конвертируется либо в меньшие счета за CI (большинство провайдеров берут поминутно), либо в более быструю обратную связь, которая стоит дороже. Отраслевое правило, которое раз за разом подтверждается: чем длиннее промежуток между «запушил» и «увидел, что упало», тем дороже исправление, потому что разработчик уже переключился на другое.
Есть и эффект второго порядка, специфичный для 2026 года: ИИ-агенты для кодинга гоняют ваш тулчейн в цикле. Агент, который генерирует код, проверяет типы, читает ошибки и пробует снова, упирается ровно в этот шаг компиляции — он может вызывать tsc десятки раз за задачу там, где человек запускает его считанные разы. Мы уже писали о том, что обвязка вокруг ИИ-агента важнее самой модели, и быстрая проверка типов — один из самых высокорычажных компонентов этой обвязки: это автоматический ревьюер, отлавливающий сгенерированную ИИ чушь до того, как её увидит человек. Если часть вашей команды пишет код промптами, а не руками, проверка типов — это ограждение, и ограждение в 10 раз быстрее означает в 10 раз более дешёвые итерации для каждого запущенного агента.
Что не меняется — и это важная половина
Именно здесь живут неверные выводы, так что скажем прямо.
Скорость работы вашего приложения: без изменений
TypeScript компилируется в JavaScript, и JavaScript на выходе нативного компилятора функционально тот же, что и раньше. Время ответа вашего API, загрузка страниц, оценки Lighthouse — ничего не сдвинется. Если ваш продукт медленный, TypeScript 7 это не исправит; причины — в вашей архитектуре, ваших запросах и вашем бандле, а не в компиляторе.
Язык: не меняется намеренно
Нативный компилятор — это порт, а не редизайн. Тот же синтаксис, та же семантика системы типов, те же концепции tsconfig. Вашим разработчикам не нужно ничего переучивать. Microsoft прямо заявила, что планка приёмки — поведенческий паритет с существующим компилятором: тестовые наборы обеих линий согласованы, чтобы это гарантировать.
Ваш код: переписывать не нужно
В ваших .ts-файлах ничего менять не нужно. Когда TypeScript 7 будет готов для вашего стека, внедрение будет выглядеть как обновление dev-зависимости и прогон тестов — ближе к бампу версии Node, чем к миграции фреймворка. Уже сегодня команды могут опробовать нативный компилятор через пакет @typescript/native-preview параллельно с текущей конфигурацией — с нулевым риском для продакшена, потому что компилятор — это инструмент времени сборки, который никогда не попадает к пользователям.
Ваша безопасность: без изменений
Более быстрый компилятор не добавляет и не исправляет уязвимости в коде, который вы поставляете. Аудит зависимостей, патчи и контроль доступа так же необходимы на следующий день после апгрейда, как и накануне.
Что может отставать: экосистема плагинов
Вот единственная честная оговорка. Инструменты, глубоко зацепленные за внутренние API старого компилятора — отдельные кастомные трансформеры, некоторые плагины language service, интеграции, программно управлявшие TypeScript API, — требуют обновления под новую архитектуру, потому что Go-бинарник не предоставляет ту же внутрипроцессную JavaScript-поверхность API. Мейнстримные тулчейны (бандлеры, тест-раннеры, редакторы) адаптируются, но если ваша сборка держится на малоизвестном плагине компилятора из 2019 года — вот пункт для аудита перед планированием перехода. Закладывайте день на разбирательство, а не квартал на миграцию.
Почему Go — и почему это важно за пределами TypeScript
Microsoft выбрала Go, а не Rust или C#, во многом потому, что структура Go позволила сделать близкий, построчный порт существующего компилятора — сохранив десять лет проверенного боем поведения вместо выведения его заново, — получив при этом нативную компиляцию и простой параллелизм с общей памятью. Урок — в прагматизме: они оптимизировали непрерывность корректности плюс производительность, а не идеологию вокруг языков.
Здесь стоит заметить и более широкий отраслевой сигнал. Паттерн «инструмент разработки переписывают на нативный язык — он получает порядок ускорения» уже устоялся: первыми через него прошли бандлеры и линтеры (esbuild на Go, swc и волна линтеров/форматтеров на Rust), а теперь следует и проверка типов — последний большой бастион на JavaScript. Сама экосистема JavaScript никуда не денется; тулинг под ней тихо становится нативным. Тем, кто нанимает или обучает разработчиков, важно заметить, чего это НЕ делает: это не снижает необходимость понимать типы, сборки и пайплайны — скорее наоборот, быстрые инструменты поднимают планку суждения; эту динамику мы разбирали в статье почему сломался конвейер джуниор-разработчиков.
Стоит ли действовать сейчас?
Вот что мы рекомендуем по ситуациям:
- Небольшая кодовая база (проверяется быстрее ~10 с): не делайте ничего. Вы перейдёте на TypeScript 7, когда он станет дефолтом в шаблоне вашего фреймворка, и почти этого не заметите.
- Большая кодовая база, медленный CI, тормозящий редактор: сначала измерьте. Засеките текущий шаг
tsc, затем прогоните нативный preview на том же коде. Если выигрыш для вас реален, планируйте переход на момент стабилизации 7.0 для вашего стека — а плагины, глубоко зацепленные за API компилятора, аудируйте уже сейчас. - Гоняете ИИ-агентов по своему репозиторию: ставьте это в приоритет. Задержка проверки типов умножается на каждую итерацию агента — именно здесь 10x даёт самый сильный кумулятивный эффект.
- Вам продают «TypeScript 7 ускорит приложение»: возражайте. Не ускорит, а вендор, утверждающий обратное, путает время сборки со временем выполнения — полезный маркер компетентности.
Главное для бизнеса:
- TypeScript 7 ускоряет создание софта, а не сам софт. Время компиляции и проверки типов падает ~в 10 раз на больших кодовых базах (VS Code: 77,8 с → 7,5 с); скорость работы вашего продукта не меняется.
- Выигрыш приземляется в пайплайн и циклы обратной связи — ниже счета за CI, быстрее обнаружение сбоев, отзывчивые редакторы на больших репозиториях и радикально более дешёвые итерации для ИИ-агентов.
- Внедрение — замена тулчейна, а не миграция. Ни переписывания кода, ни переобучения — язык намеренно идентичен. Единственная предполётная проверка — не зависит ли ваша сборка от плагинов, вшитых во внутренности старого компилятора.
Статья подготовлена на основе открытых источников и может содержать неточности.


