TypeScript 7 на Go: что меняет в большом проекте tsc, который стал в десять раз быстрее

•
Опубликовано
•
12 мин чтения

Текст написан с позиции июля 2026 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.

Есть редкая категория изменений, которые не добавляют в язык ни одной новой конструкции, но заметно меняют то, как с ним работают каждый день. Нативный порт компилятора TypeScript на Go — ровно такой случай. Синтаксис тот же, система типов та же, ошибки те же. Поменялось другое: время, за которое ты узнаёшь, что ошибся. И на большом проекте именно это время определяет, как команда пишет код, сколько стоит CI и насколько охотно люди вообще смотрят на type errors.

Напомню контекст. В марте 2025 года команда TypeScript анонсировала переписывание компилятора и language service на Go с целью ускорения примерно на порядок. В анонсе приводили наглядный пример: проверка кодовой базы VS Code, около полутора миллионов строк, сокращалась примерно с 77 до 7,5 секунды. Тогда же появился preview-пакет @typescript/native-preview с бинарником tsgo, а нумерация версий получила понятную логику: ветка 6.x остаётся последней на JavaScript-кодовой базе и служит мостом, а 7 — это уже нативная реализация.

Самая вредная реакция на эту новость — услышать «в десять раз быстрее» и решить, что это просто приятный бонус: сборка короче, можно реже ходить за кофе. На деле всё интереснее. Когда обратная связь ускоряется на порядок, меняется не длительность старых действий, а набор действий, которые вообще имеет смысл совершать. И одновременно всплывает счёт за всё, что годами было завязано на JavaScript API компилятора. Об этих двух сторонах и поговорим.

Скорость проверки — это свойство процесса, а не утилиты

Почему порядок ускорения так важен? Потому что у человеческого внимания есть пороги. Проверка, которая занимает полсекунды, воспринимается как мгновенная. Пять секунд — уже пауза, но поток не рвётся. Минута — это переключение контекста: открыл чат, посмотрел почту, вернулся и забыл, что именно проверял. Большой монорепозиторий на TypeScript 5.x жил как раз в третьей зоне: полный tsc --noEmit занимал минуты, и люди закономерно перестали его запускать локально, переложив эту обязанность на CI.

Ускорение в десять раз переносит проект из одной зоны в другую. Минута превращается в несколько секунд, и полная проверка типов снова становится действием, которое делают руками и без раздумий — перед коммитом, после rebase, после крупного рефакторинга. Это не косметика, а смена жанра: type check возвращается из разряда «инфраструктурной процедуры» в разряд обычного инструмента разработчика, как линтер или форматтер.

Отсюда архитектурный вывод, который проще всего пропустить. Важна не абсолютная скорость компилятора, а длина петли обратной связи между изменением и знанием о его последствиях. Чем она короче, тем дешевле ошибка, тем смелее рефакторинг и тем меньше команде нужно полагаться на память и аккуратность конкретного человека. Нативный tsc укорачивает именно эту петлю.

Редактор перестаёт думать вслух

Для большинства разработчиков первый и самый ощутимый эффект проявляется вовсе не в терминале, а в редакторе. Language service на больших проектах годами был источником мелкой, но постоянной боли: долгий старт после открытия workspace, подвисающие подсказки, «Loading…» в hover, перезапуск TS server как ритуал при любой странности. Каждый из этих эпизодов короткий, но вместе они создают фон, в котором ты подсознательно перестаёшь доверять подсветке ошибок.

Нативная реализация бьёт ровно в эту точку. Загрузка проекта, ответы на автодополнение, поиск ссылок и переименование символа в большом коде становятся заметно отзывчивее, а потребление памяти — скромнее. Отдельно стоит отметить переход на Language Server Protocol как основной способ общения с редактором: вместо собственного протокола tsserver — стандартный LSP, который понимают не только VS Code, но и остальные редакторы без отдельных прослоек.

Но важно не свалиться в другую крайность. Быстрый language service не делает типы проще. Если в проекте есть рекурсивные conditional types на десятки уровней или гигантские union, которые раньше «думались» по несколько секунд, то теперь они будут думаться заметно быстрее, но по-прежнему дольше, чем всё остальное. Скорость нативного компилятора — это множитель, а не отмена сложности. Плохо спроектированный тип остаётся плохо спроектированным, просто его стало чуть легче не замечать.

Что происходит с watch mode и проверкой на каждое сохранение

Watch mode в больших проектах на 5.x был компромиссом. Инкрементальная проверка работала, но первый прогон и пересчёт после изменения в «корневом» типе, от которого зависит половина кода, могли занимать ощутимое время. Поэтому многие команды держали два режима: быстрый bundler без типов для разработки и отдельную проверку типов где-то сбоку, на которую смотрели, когда вспоминали.

С ускорением на порядок этот компромисс начинает выглядеть иначе. Проверка типов на каждое сохранение перестаёт быть роскошью для маленьких проектов и становится разумным дефолтом для больших. Схема «bundler транспилирует, а типы проверяются фоном» никуда не уходит — разделение транспиляции и проверки по-прежнему правильная архитектура. Меняется другое: фоновая проверка догоняет тебя раньше, чем ты успел переключиться на следующую задачу, и ошибка приходит, пока контекст ещё в голове.

Отдельная выгода — параллелизм. Нативная реализация умеет использовать несколько ядер там, где JavaScript-версия была фактически однопоточной. На рабочей машине с современным процессором это ощущается особенно сильно: раньше большая часть ядер просто простаивала, пока tsc честно разбирал файлы по одному.

CI дешевеет, но экономия не всегда там, где её ждут

Самое очевидное ожидание — сократится время пайплайна. Оно действительно сокращается, но приземлим до конкретики. В типичном CI фронтенд-монорепозитория проверка типов — один из нескольких тяжёлых шагов наряду с установкой зависимостей, тестами, сборкой и линтингом. Если type check занимал четыре минуты из пятнадцати, то после перехода он займёт полминуты, а пайплайн — около одиннадцати. Это хорошо, но не в десять раз. Узким местом становится то, что раньше пряталось за проверкой типов.

Интереснее вторичные эффекты. Во-первых, исчезает часть инфраструктурных ухищрений, которые строились ради экономии времени на tsc: хитрое кэширование .tsbuildinfo между джобами, проверка только затронутых пакетов через граф зависимостей, разнесение type check по нескольким параллельным раннерам. Всё это было оправдано, когда проверка шла минутами. Когда она идёт секундами, каждое такое ухищрение превращается в код, который надо поддерживать ради выигрыша, которого больше нет.

Во-вторых, меняется экономика pre-commit и pre-push проверок. Раньше полный type check в git hook был плохой идеей — он раздражал и его отключали. Теперь его снова можно рассматривать, хотя бы для изменённых пакетов. Это не обязательная практика, но вариант, который вернулся на стол.

Монорепозиторий получает шанс отказаться от части собственной сложности

В больших монорепозиториях на TypeScript 5.x значительная часть архитектуры сборки существовала не ради предметной логики, а ради скорости компилятора. Project references, дробление на множество tsconfig, искусственные границы между пакетами, обязательные declaration-файлы на каждом уровне — многое из этого появлялось потому, что проверить всё целиком было слишком долго.

Нативный компилятор не отменяет project references — они по-прежнему полезны как способ явно зафиксировать границы между частями системы. Но он меняет мотивацию. Раньше границу проводили потому, что иначе всё тормозит. Теперь её стоит проводить только там, где она отражает реальную архитектурную границу: отдельно публикуемый пакет, независимая команда, другой цикл релизов. Это не упрощение ради упрощения, а возможность убрать слой, который существовал по производственной, а не по архитектурной причине.

Здесь легко перегнуть палку. Если завтра схлопнуть весь монорепозиторий в один гигантский tsconfig «потому что теперь быстро», вы потеряете явные контракты между пакетами, которые помогали людям не тащить внутренности одного модуля в другой. Скорость — повод пересмотреть структуру, а не повод её выбросить.

Счёт приходит тем, кто жил внутри компилятора

Теперь о цене. Для пользователя, который запускает tsc и открывает редактор, переход почти незаметен. Для всех, кто годами обращался к компилятору как к JavaScript-библиотеке, ситуация совсем другая. Старый мир позволял сделать import ts from 'typescript' и получить доступ к AST, type checker, трансформерам и внутренним структурам прямо в своём процессе. На этом выросла огромная экосистема: кастомные трансформеры, плагины language service, генераторы кода, линтеры с type-aware правилами, инструменты документации, анализаторы зависимостей.

Нативный компилятор — это отдельный бинарник на Go, а не JavaScript-модуль. Его внутренние объекты нельзя просто так взять и потрогать из Node-процесса. Команда TypeScript открыто говорила, что программный API будет устроен иначе — с обменом данными между процессами — и что совместимость со старым API в полном объёме не цель. Поэтому всё, что опиралось на внутренности 5.x, требует отдельной ревизии: что-то уже переехало, что-то переезжает, что-то придётся заменить.

Практически это выглядит так. Нужно составить честный список всех мест, где проект или его тулинг импортирует пакет typescript не ради запуска CLI, а ради API. Обычно туда попадают: type-aware правила линтера, плагины language service из compilerOptions.plugins, кастомные трансформеры через обёртки вроде ts-patch, генераторы типов и схем, инструменты документации. Для каждого пункта нужен ответ: поддерживает ли он нативную версию, есть ли замена, можно ли временно держать рядом старый пакет. Это не катастрофа, но это работа, и её стоит планировать, а не обнаруживать в день обновления.

Можно ли просто поменять версию в package.json?

Для маленького проекта с аккуратным tsconfig — часто да. Для большого проекта с историей — почти никогда. Причина не в нативном порте как таковом, а в том, что ему предшествовала волна чистки. Ветка 6.x объявила устаревшими ряд опций и режимов, которые годами тянулись ради обратной совместимости: старые стратегии разрешения модулей, древние target, некоторые исторические флаги. В нативной версии многое из этого уже не поддерживается. Проект, который проигнорировал предупреждения 6.x, встретит их в 7 в виде ошибок конфигурации.

Поэтому разумная последовательность выглядит так. Сначала довести проект до чистого состояния на последней 6.x: без предупреждений об устаревших опциях, с современными настройками модулей. Параллельно прогнать нативный компилятор в CI как необязательный шаг и сравнить список ошибок со старым. Расхождения бывают — в порядке вывода, в формулировках, изредка в краевых случаях вывода типов — и их лучше увидеть до того, как от результата зависит зелёный билд. Только после этого переключать основную проверку.

Есть и организационная сторона. На переходный период в проекте фактически живут два компилятора: нативный для проверки и редактора, JavaScript-версия для инструментов, которые ещё не переехали. Это допустимо, но это временный долг, и у него должен быть понятный срок погашения. Иначе через год вы обнаружите, что два компилятора стали постоянной частью архитектуры, а расхождения между ними — постоянным источником странных багов.

Быстрый компилятор не отвечает на вопрос, хорошие ли у вас типы

Важно честно проговорить, чего нативный порт не делает. Он не улучшает модель типов, не находит новых классов ошибок и не делает код безопаснее сам по себе. Проект, где половина данных приходит как any, а другая половина прикрыта as unknown as, будет проверяться быстрее — и ровно так же бесполезно. Скорость усиливает уже существующую дисциплину, но не создаёт её.

Есть и менее очевидный риск. Когда проверка становится мгновенной, возникает соблазн строить ещё более изощрённые типы: «теперь же всё быстро». Это та же ловушка, что и с любым ресурсом, который внезапно подешевел. Сложность типов стоит не только времени компилятора, но и времени людей, которые будут читать эти типы через полгода, разбираться в сообщениях об ошибках на сорок строк и бояться их трогать. Компилятор ускорился в десять раз, человек — нет.

Наконец, переход несёт стоимость поддержки сам по себе. Новый бинарник, новый способ интеграции, новые баги, которые неизбежны в любой большой переписанной системе, обновление CI-образов, проверка поведения на разных платформах. Для стабильного продукта, у которого проверка и так занимает двадцать секунд, выгода может оказаться меньше этой стоимости — и спешить там некуда.

Где выигрыш окупает переход быстрее всего

Если смотреть через призму стоимости и выгоды, картина довольно ясная. Быстрее всего переход окупается в больших монорепозиториях, где полная проверка занимала минуты, где редактор заметно подтормаживал и где CI тратил на type check существенную долю времени. Там нативный компилятор меняет не цифры в отчёте, а поведение людей: они начинают чаще проверять, смелее рефакторить и меньше полагаться на «CI потом скажет».

Медленнее всего — в проектах с плотной интеграцией в API компилятора: собственные трансформеры, сложные кодогенераторы, плагины language service. Там переход сначала приносит работу и только потом пользу. Это не повод его откладывать бесконечно, но повод планировать его как отдельную задачу со сроками, а не как обновление зависимости между делом.

Отдельно скажу про библиотеки. Авторам пакетов, которые публикуют .d.ts, полезно проверить свои типы на нативной версии заранее, даже если сами они пока не переходят. Пользователи библиотеки перейдут раньше, и если ваши декларации ведут себя иначе или проверяются заметно медленнее остальных, вы узнаете об этом из issue, а не из собственного CI.

Итог

TypeScript 7 на Go — это не новая версия языка, а новая скорость работы с ним. Ускорение примерно на порядок переносит большие проекты из зоны «проверка типов — это процедура в CI» в зону «проверка типов — это обычная реакция на сохранение файла». Редактор становится отзывчивее, watch mode — практичнее, CI — короче, а часть инфраструктуры, построенной ради экономии времени на tsc, теряет смысл и может быть убрана.

Цена тоже реальна. Всё, что жило внутри JavaScript API компилятора, требует ревизии; устаревшие опции, проигнорированные в 6.x, возвращаются ошибками; переходный период с двумя компиляторами — это долг, который нужно гасить осознанно. И ни одна из этих скоростей не исправит слабую модель типов.

Если сформулировать главный практический вывод совсем прямо, он звучит так. Нативный компилятор ценен не тем, что экономит минуты, а тем, что укорачивает петлю обратной связи настолько, что проверка типов снова становится частью мышления, а не частью пайплайна — и переходить на него стоит с инвентаризации всего, что зависит от старого API, а не с правки версии в package.json.

Автор

Senior Principal JavaScript Developer, Tech Lead. Пишет о React, TypeScript, React Native, архитектуре фронтенда и бэкенда и о том, как AI меняет работу разработчика.

Читайте также