Python давно стал почти стандартным инструментом для машинного обучения, анализа данных и научных задач. Однако в вычислительно сложных проектах его производительность быстро становится ощутимым ограничением. Поэтому под привычными NumPy, PyTorch и другими инструментами значительная часть вычислений выполняется компонентами на C, C++ или CUDA. Особенно заметно это становится, когда готовых библиотечных функций недостаточно и высокопроизводительные операции приходится писать самостоятельно.

Несколько лет назад за решение этой проблемы взялась компания Modular, представившая Mojo — новый язык, внешне очень похожий на Python, но построенный иначе. Первую публичную версию показали в 2023 году, после чего проект довольно быстро менялся, а некоторые его конструкции успели исчезнуть или несколько раз поменять форму. Теперь этот этап формально завершен: 11 августа 2026 года вышел Mojo 1.0. Первая стабильная версия стала хорошим поводом разобраться, откуда вообще взялся этот необычный проект и зачем понадобился еще один инструмент для высокопроизводительных вычислений.

Откуда вообще взялся Mojo

Modular появилась в начале 2022 года, ее основателями стали Крис Латтнер и Тим Дэвис. Первый хорошо известен как создатель LLVM и Swift, а также один из ключевых авторов Clang и MLIR. Дэвис много лет развивал инфраструктуру машинного обучения в Google, в том числе работал с TensorFlow, XLA и MLIR. В Modular они разрабатывали собственную вычислительную платформу для искусственного интеллекта. Партнеры быстро столкнулись с привычной для этой области проблемой: одна ИИ-система часто зависит от нескольких разнородных технологий, каждая из которых отвечает за свой уровень вычислений.

Такую сложную проблему нельзя было решить созданием очередной библиотеки. Команде требовался инструмент, позволяющий описывать и высокоуровневую логику программ, и низкоуровневые операции без переключения между разными средами разработки. Результатом стал Mojo, ЯП представили вместе с вычислительной платформой Modular. Поначалу опробовать новинку можно было только через облачный Mojo Playground, поскольку локального SDK еще не существовало. Интерес оказался немаленьким: к началу сентября в Playground зарегистрировались более 120 тысяч человек, после чего Modular выпустила инструментарий для локальной установки на Linux.

Почему в качестве отправной точки разработчики выбрали именно Python? Дело в том, что язык лидирует в области машинного обучения и анализа данных, а создание совершенно нового синтаксиса означало бы дополнительный барьер для потенциальной аудитории. Поэтому авторы Mojo сделали его синтаксически близким к Python. Однако за знакомой оболочкой скрывается самостоятельный компилируемый язык со своей моделью памяти, системой типов и правилами выполнения программ.

Сначала в Modular планировали сделать Mojo надмножеством Python — предполагали, что язык сможет исполнять чистый Python-код, параллельно открывая возможности системного программирования. Пока до этого не дошло, и Mojo развивается как независимый язык, а интеграцию с Python разработчики обеспечили за счет импорта существующих пакетов. Поэтому популярное ранее определение «Python++» отлично отражает идею проекта, но не его архитектуру на данный момент.

Постепенно менялось и позиционирование проекта. В 2023 году авторы представляли Mojo прежде всего как специализированный инструмент для задач искусственного интеллекта и высокопроизводительных расчетов, глубоко интегрированный с экосистемой Modular. Теперь же компания продвигает Mojo как системный язык общего назначения, на котором потенциально можно писать не только компоненты ИИ-систем, но и другое производительное ПО. При этом первоначальная специализация никуда не исчезла: компиляторная инфраструктура, работа с памятью, SIMD и разными типами процессоров по-прежнему остаются ключевыми особенностями языка.

Каталог готовых ИИ‑моделей

Сервис для запуска и управления LLM в облаке Selectel. Выберите модель, конфигурацию и получите готовый эндпоинт для работы с ней.

Подробнее →

Зачем нужен новый язык и что скрывается за синтаксисом Python

Одна из основных проблем, на которую нацелился Mojo, иногда называется «двухъязычной» моделью разработки. На Python удобно собирать алгоритмы, экспериментировать и описывать общую логику, но критически важные для производительности участки кода разработчики часто вынуждены переписывать на других языках. Пока нужные функции есть в библиотеках вроде NumPy или PyTorch, это незаметно. Сложности начинаются при создании собственного вычислительного ядра, нестандартной оптимизации или поддержке нового оборудования. В этих случаях приходится спускаться на уровень системного программирования, где действуют совершенно другие правила работы с типами данных, памятью и аппаратными ресурсами.

Mojo ставит перед собой задачу сократить расстояние между этими слоями. В нем есть статическая типизация с выводом типов, структуры, параметрическое программирование, ссылки, SIMD-операции и средства для непосредственной работы с памятью. В одном месте программа выглядит как простой Python-скрипт, а в другом — позволяет детально контролировать размещение данных в памяти и стоимость вычислений. Компилятор при этом знает о значениях переменных значительно больше, чем CPython во время исполнения, и может использовать эту информацию для оптимизации. Именно этот контроль важнее внешнего сходства с Python: знакомый синтаксис сам по себе никакого выигрыша в скорости не дает.

На простом примере различия могут быть почти незаметны. Функции объявляются через def, блоки определяются отступами, а if, for и while выглядят привычно. Переменные в современном Mojo явно создаются через var, при необходимости для них можно указывать типы, хотя значительную часть информации система способна вывести самостоятельно. В результате исходник не превращается в длинную последовательность деклараций, характерную для некоторых системных языков. Однако по мере «приближения к железу» отличия от Python становятся все заметнее.

Особенно заметны отличия при работе с памятью. В Mojo каждое значение принадлежит одной переменной, но другие участки программы могут обращаться к нему по ссылке без создания дубликатов. Похожий подход применяется в Rust, хотя конкретные правила в Mojo отличаются. Компилятор следит за тем, чтобы ссылки оставались действительными, и обнаруживает ситуации, способные привести к обращению к уже недоступным данным. Например, если изменение контейнера сделало ранее полученную ссылку на его содержимое недействительной, Mojo может сообщить об ошибке еще при компиляции. В Python подобные детали обычно скрыты от программиста. Тем не менее, при работе с памятью напрямую они важны и для производительности, и для безопасности программы.

Еще одно важное отличие от Python — способ выполнения программы. Код Mojo можно заранее скомпилировать в самостоятельный исполняемый файл, которому для запуска не нужен интерпретатор Python. При компиляции уже известны типы данных и другие параметры программы, поэтому компилятор может заранее подобрать и оптимизировать код под конкретную задачу. Mojo также поддерживает метапрограммирование: часть вычислений и проверок можно выполнить еще на этапе компиляции, а на их основе создать специализированный вариант функции. В результате разработчик получает больше возможностей управлять тем, какой машинный код в итоге будет выполняться, что особенно важно для высокопроизводительных вычислений.

Большую роль в Mojo играет MLIR — компиляторная инфраструктура, одним из создателей которой был Крис Латтнер. Если сильно упростить, обычному компилятору нужно превратить написанную человеком программу в машинный код, понятный процессору. MLIR позволяет делать это в несколько этапов: сначала сохранить информацию о высокоуровневых операциях программы, а затем постепенно преобразовать их в команды, рассчитанные на конкретное оборудование. Такой подход особенно полезен для Mojo, который должен работать не только на центральных процессорах (CPU), но и на графических ускорителях (GPU) и специализированных AI-чипах. Поэтому MLIR был заложен в архитектуру языка с самого начала и во многом определяет то, как Mojo может сочетать сравнительно высокоуровневый синтаксис с низкоуровневой оптимизацией.

Благодаря такой архитектуре разработчики Mojo обещают производительность на уровне C и C++. В ранних демонстрациях Modular заявляла особенно впечатляющие результаты: в отдельных задачах оптимизированный код Mojo работал в десятки тысяч раз быстрее аналогичного варианта на Python.

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

Смысл языка в другом: он предоставляет инструменты для постепенной оптимизации узких мест программы и достижения скорости системного C++ без необходимости переписывать проект на другой язык.

Что изменилось в Mojo 1.0

Финальная Mojo 1.0 вышла 11 августа 2026 года вместе с Modular 26.5. Предыдущие ветки — 1.0.0b1 от 7 мая и 1.0.0b2 от 18 июня — позволили сообществу протестировать изменения до официального запуска. Главное новшество здесь скорее организационное, чем техническое: Modular считает архитектуру языка достаточно зрелой и намерена сохранять совместимость в рамках ветки 1.x. Это не означает, что язык теперь вообще не будет меняться: при необходимости компания допускает изменения, из-за которых старый код придется исправлять. Однако после выхода 1.0 такие случаи должны происходить значительно реже.

К выпуску 1.0 разработчики постарались сделать синтаксис более последовательным, избавившись от дублирующих конструкций. Переменные теперь объявляются через var, для указателей оставлен единый тип Pointer, а работа с замыканиями приведена к общим правилам. Одновременно в языке появились лямбда-функции с привычным для Python синтаксисом. В целом Modular старается использовать знакомые по Python конструкции там, где они подходят, а собственные добавляет в тех случаях, когда нужны возможности системного языка.

Большое внимание авторы уделили развитию экосистемы вокруг языка. Разработчики улучшили LSP-сервер, отвечающий за подсказки, навигацию по исходникам и диагностику в редакторах вроде VS Code. Компилятор стал подробнее сообщать о потенциальных ошибках при работе с памятью и ссылками, что особенно важно после закрепления модели владения. Подобные изменения не так эффектно смотрятся в пресс-релизах, как очередной впечатляющий бенчмарк, но именно от них во многом зависит удобство повседневной разработки. К первой стабильной версии Modular явно старалась довести до приемлемого состояния не только синтаксис, но и окружающий его инструментарий.

За время открытого тестирования значительно выросла и стандартная библиотека языка. После публикации ее исходного кода почти 200 участников сообщества внесли более 1 100 изменений, затронувших свыше 200 000 строк. Еще более тысячи человек сообщали об ошибках и предлагали улучшения. Для трехлетнего проекта это довольно активное сообщество, хотя до масштабов Python, C++ или Rust пока далеко.

Выход стабильной версии должен облегчить также разработку сторонних библиотек: их авторам больше не придется так часто переделывать код вслед за изменениями самого Mojo. Теперь успех языка зависит от скорости формирования зрелой экосистемы пакетов.

Релиз версии 1.0 не останавливает развитие Mojo. В планах разработчиков остаются асинхронное программирование, сопоставление с образцом, объединения типов и другие возможности. Пока компания открыла не весь проект: стандартная библиотека доступна под лицензией Apache 2.0, но исходный код компилятора и части внутренних инструментов Modular еще не опубликовала. Авторы планируют выложить их в открытый доступ до конца 2026 года. Таким образом, версия 1.0 фиксирует базис языка — его ключевые механизмы и синтаксис сформировались и больше не будут подвергаться частым ломающим изменениям.