Крис Латтнер (Chris Lattner) — создатель CPU-компилятора LLVM и соавтор Swift — предложил новый язык программирования Mojo, спроектированный для одновременного программирования CPU, GPU и TPU (тензорные ядра, оптимизированные для матричного умножения, а это и есть инференс LLM), без всяких лишних библиотек типа CUDA, ROCm и XLA.

Mojo — это надмножество Python с производительностью С и потенциальная замена Rust. Код на нём легко переносится между различными GPU, при этом платформа Modular быстрее обновляется под новые модели GPU, чем сама Nvidia выпускает обновления для своего софта (новые attention kernels).

Простой и мощный язык для написания и деплоя LLM-приложений независимо от оборудования (AMD, Nvidia, Intel и проч.), с метапрограммированием во время компиляции и прочими штуками. Что-то вроде единой «LLVM для AI». Унифицированная программная платформа, которая запускается на любом железе. Это ещё и самый простой способ ускорить Python-приложение в 10−1000 раз, не переписывая его фрагменты на Rust или C++ (что по сути делают NumPy и PyTotch).

Учёба и начало карьеры

В детстве Крис самостоятельно научился программированию, черпая информацию с BBS и из интернета начала 90-х. В те времена приходилось выжимать из слабого железа максимум возможного, чтобы программы работали без тормозов.

В Портлендский университет он уже пришёл настоящим «ботаником», и параллельно с учёбой занимался разработкой операционной системы DYNIX/ptx в компании Sequent. В аспирантуре Урбана-Шампейна разрабатывал компилятор LLVM, темой диссертации стал «Анализ и оптимизация макроскопических структур данных» (с помощью LLVM), то есть оптимизация программ, интенсивно использующих указатели.

Затем двенадцать лет работал в Apple, где дорос до директора подразделения Developer Tools (инструменты для разработчиков).

В последующие пять лет занимал разные должности в Tesla, Google и SiFive, а в 2022 году они с коллегой из Google основали стартап Modular AI, который и продвигает новый язык программирования Mojo и фреймворк MAX.

Проекты Латтнера

Чтобы понять истоки Mojo, нужно посмотреть на предыдущие разработки Латтнера:

• LLVM (с 2000 года): компилятор стал темой диссертации Латтнера и, вероятно, аргументом для трудоустройства в Apple в 2005 году.

• Clang (2007) — LLVM-фронтенд для языков программирования C и С++ (с 2010 года), написанный на С++. Он транслирует исходные коды в байт-код LLVM, затем производит оптимизации и кодогенерацию.

• Swift (2010) — системный язык программирования для разработки приложений Apple. Крис писал Swift как хобби-проект по вечерам и выходные, чтобы восстановиться от выгорания на основной работе в Apple, где он руководил коллективом 20−40 человек и доделывал Clang. В те времена он понял, что в области языков программирования огромное поле для совершенствования, потому что популярные языки типа С, С++ и Java не поддерживали даже сопоставление с образцом (как в OCaml), не говоря о других полезных и красивых методах.

• MLIR (Multi-Level Intermediate Representation) — компилятор Clang на базе LLVM, своего рода LLVM 2.0 (написан во время работы Криса в Google), с поддержкой GPU и AI-приложений, но без унификации, то есть для него требуется использовать CUDA от Nvidia, XLA от Google, ROCm от AMD и так далее до бесконечности — у каждой крупной компании свой программный стек. При этом существуют прекрасные высокоуровневые технологии вроде PyTorch, но с ними тоже тяжело работать, если использовать несколько разных технологических стеков типа CUDA/XLA/ROCm на нижнем уровне.

Это выглядит примерно так:

Отсутствие унифицированной программной инфраструктуры сильно портит жизнь ML-разработчикам:

• наконец, Mojo — новый язык программирования для ML.

Почему ML нужен свой ЯП

В подкасте Signals & Threads Крис Латтнер говорит, что со временем все замечательные проекты обрастают эдаким «грузом» улучшений и совершенствований, так что они:

• никогда не станут проще (никто не будет удалять функции языка);

• страдают от лишних вещей, усложняющих жизнь и которых лучше бы не было.

Это проблемы и LLVM, и Swift, и C++. Там отличное большое сообщество, которое улучшает язык и постоянно вносит совершенствования, пытается устранить недостатки, но это сизифов труд. Иногда легче написать с нуля.

Mojo и Modular пытаются решить структурную проблему отрасли — отсутствие единой программной платформы для ML-приложений.

В качестве исторического предшественника Крис называет Google XLA и опенсорсный проект TVM (An Open Machine Learning Compiler Framework):

Но TVM так и не взлетел: ключевые разработчики основали компанию OctoAI, которую Nvidia купила в 2024 году.

В свою очередь, технически совершенный и опенсорсный MLIR тоже не смог поколебать засилье CUDA, хотя было несколько попыток создать универсальный ent-to-end компилятор для AI-систем на его основе: OpenXLA, TritonLang и др. Попытки продолжаются, а Mojo/Modular — один из таких претендентов.

Mojo

Mojo разработан специально для современной гетерогенной инфраструктуры ИИ, то есть дата-центров с CPU, GPU и AI-чипами. Знакомый питоновский синтаксис должен привлечь программистов, и язык полностью интегрируется с существующей экосистемой Python, включая богатство библиотек для AI и ML.

Это первый в мире ЯП, созданный с нуля специально для MLIR. То есть один язык для всего кода: от высокоуровневых приложений ИИ до низкоуровневых ядер GPU, без применения каких-то аппаратных библиотек (типа CUDA и ROCm). Разработка и поддержка приложений значительно упрощается.

Ключевые функции

• Python-синтаксис. Mojo заимствует (и расширяет) синтаксис Python и интегрируется в существующий питоновский код. Это двустороннее взаимодействие: можно импортировать библиотеки Python в Mojo и создавать Mojo-привязки для Python-вызовов.

• Типы на основе структур. Все типы данных, включая базовые String, Int и др., определены как структуры. Типы не встроены в сам язык. Это означает, что можно определять собственные типы со всеми возможностями, что у типов стандартной библиотеки:

struct MyPair:
    var first: Int
    var second: Int

    fn __init__(out self, first: Int, second: Int):
        self.first = first
        self.second = second

• Система трейтов Mojo решает проблему статической типизации: трейты определяют общее поведение для типов (структур). Это позволяет писать функции, зависящие от трейтов, а не от конкретных типов, аналогично интерфейсам Java или протоколам Swift, за исключением проверки типов на этапе компиляции и отсутствия затрат на производительность во время выполнения.

@fieldwise_init
struct Duck(Copyable, Movable):
    fn quack(self):
        print("Quack")

@fieldwise_init
struct StealthCow(Copyable, Movable):
    fn quack(self):
        print("Moo!")

fn make_it_quack(definitely_a_duck: Duck):
    definitely_a_duck.quack()

fn make_it_quack(not_a_duck: StealthCow):
    not_a_duck.quack()

make_it_quack(Duck())
make_it_quack(StealthCow())

• Система владения Mojo гарантирует, что только одна переменная в данный момент «владеет» определённым значением. Таким образом, Mojo безопасно освобождает память, когда жизненный цикл владельца завершается, при этом позволяя делиться ссылками на это значение. Это сразу устраняет некоторые уязвимости и ошибки, такие как обращение к освобождённой памяти, двойное освобождение и утечки памяти, без траты ресурсов на сборку мусора. Это одна из причин, почему Mojo можно использовать вместо Rust.

• Метапрограммирование во время компиляции. Система параметризации Mojo (идея позаимствована из Zig) предлагает выполнять продвинутое метапрограммирование, когда компилятор генерирует уникальную версию типа или функции на основе значений параметров, аналогично шаблонам C++, но интуитивно понятнее и проще:

fn repeat[count: Int](msg: String):
    @parameter
    for i in range(count):
        print(msg)

• Аппаратная переносимость. Mojo изначально разработан с поддержкой разного железа. Пакет gpu обеспечивает независимое от платформы программирование GPU, а фреймворк предусматривает синхронизацию CPU и GPU.

from gpu.host import DeviceContext
from gpu.id import block_dim, block_idx, thread_idx
from math import iota
from sys import exit
from sys.info import has_accelerator

alias num_elements = 20

fn scalar_add(vector: UnsafePointer[Float32], size: Int, scalar: Float32):
    """
    Kernel function to add a scalar to all elements of a vector.

    This kernel function adds a scalar value to each element of a vector stored
    in GPU memory. The input vector is modified in place.

    Args:
        vector: Pointer to the input vector.
        size: Number of elements in the vector.
        scalar: Scalar to add to the vector.

    """

    # Calculate the global thread index within the entire grid. Each thread
    # processes one element of the vector.
    #
    # block_idx.x: index of the current thread block.
    # block_dim.x: number of threads per block.
    # thread_idx.x: index of the current thread within its block.
    idx = block_idx.x * block_dim.x + thread_idx.x

    # Bounds checking: ensure we don't access memory beyond the vector size.
    # This is crucial when the number of threads doesn't exactly match vector
    # size.
    if idx < UInt(size):
        # Each thread adds the scalar to its corresponding vector element
        # This operation happens in parallel across all GPU threads
        vector[idx] += scalar

def main():
    @parameter
    if not has_accelerator():
        print("No GPUs detected")
        exit(0)
    else:
        # Initialize GPU context for device 0 (default GPU device).
        ctx = DeviceContext()

        # Create a buffer in host (CPU) memory to store our input data
        host_buffer = ctx.enqueue_create_host_buffer[DType.float32](
            num_elements
        )

        # Wait for buffer creation to complete.
        ctx.synchronize()

        # Fill the host buffer with sequential numbers (0, 1, 2, ..., size-1).
        iota(host_buffer.unsafe_ptr(), num_elements)
        print("Original host buffer:", host_buffer)

        # Create a buffer in device (GPU) memory to store data for computation.
        device_buffer = ctx.enqueue_create_buffer[DType.float32](num_elements)

        # Copy data from host memory to device memory for GPU processing.
        ctx.enqueue_copy(src_buf=host_buffer, dst_buf=device_buffer)

        # Compile the scalar_add kernel function for execution on the GPU.
        scalar_add_kernel = ctx.compile_function[scalar_add]()

        # Launch the GPU kernel with the following arguments:
        #
        # - device_buffer: GPU memory containing our vector data
        # - num_elements: number of elements in the vector
        # - Float32(20.0): the scalar value to add to each element
        # - grid_dim=1: use 1 thread block
        # - block_dim=num_elements: use 'num_elements' threads per block (one
        #   thread per vector element)
        ctx.enqueue_function(
            scalar_add_kernel,
            device_buffer,
            num_elements,
            Float32(20.0),
            grid_dim=1,
            block_dim=num_elements,
        )

        # Copy the computed results back from device memory to host memory.
        ctx.enqueue_copy(src_buf=device_buffer, dst_buf=host_buffer)

        # Wait for all GPU operations to complete.
        ctx.synchronize()

        # Display the final results after GPU computation.
        print("Modified host buffer:", host_buffer)

Платформа Modular

На языке Mojo в контейнере с фреймворком MAX работает платформа Modular, которая выполняет инференс LLM на любом железе, включая GPU от Nvidia и AMD (рекомендуются Nvidia B200/H200/H100 или AMD MI355X/MI325X/MI300X, см. список совместимых GPU).

Опенсорсную версию Modular можно бесплатно установить на своём сервере:

Платная версия продаётся как SaaS-решение. Это похоже на более продвинутую и высокопроизводительную оболочку типа Ollama для запуска моделей, которые скачиваются с Hugging Face. В свою очередь, фреймворк MAX можно рассматривать как более производительную замену vLLM или PyTorch.

Запуск модели из командной строки после установки контейнера Modular:

max serve --model google/gemma-3-27b-it

Создание файла generate-text.py, который отправляет запрос на инференс:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

completion = client.chat.completions.create(
   model="google/gemma-3-27b-it",
   messages=[
       {
         "role": "user",
         "content": "Who won the world series in 2020?"
       },
   ],
)

print(completion.choices[0].message.content)

После серверов с MAX есть ещё следующий уровень Mammoth, это уровень управления кластером Kubernetes.

Сейчас 47-летний Крис Латтнер с женой и детьми живёт в Калифорнии. Жена Таня — тоже разработчица компиляторов, ещё студенткой в 2005 году принимала участие в разработке LLVM, затем в 2015 году с Крисом соосновала благотворительную организацию LLVM Foundation и до сих руководит ею как COO, входила в список самых влиятельных программисток мира.

Судя по личному блогу, Крис увлекается столярным делом:

В своё время созданный Крисом компилятор LLVM стал фундаментом для Swift, Rust, Julia и многих других современных ЯП. Язык программирования Swift стал заменой Objective-C для программирования под iOS. Вообще, Латтнер всю жизнь посвятил разработке компиляторов и языков программирования. Он уже проделал такую «революцию» два раза с LLVM и Swift, почему не получится в третий? Mojo логично вписывается в эту историю.

Несколько дней назад стартап Modular привлёк $250 млн венчурного финансирования. Это огромные ресурсы для создания «универсальной платформы для AI».

© 2025 ООО «МТ ФИНАНС»