ИИтог

NVIDIA принесла в CUDA нативный Rust для GPU-ядер

инструментыРедакция ИИтогHacker News🔥82Рейтинг ИИтог82Влияние72Новизна72Релевантность92Неожиданность48Участники88Достоверность87
NVIDIA принесла в CUDA нативный Rust для GPU-ядер

В сентябре 2026 года NVIDIA объявила, что делает ставку на нативное программирование GPU на Rust. До сих пор CUDA C++ и CUDA Python оставались зрелыми промышленными инструментами, а Rust на GPU был исключением: с него можно было запускать ядра, но само тело ядра всё равно приходилось писать на другом языке. Компания объясняет интерес к Rust тем, что системный слой ИИ-инфраструктуры, движки инференса, серверная обвязка, драйверы, среды выполнения агентов, постоянно меняется вместе с моделями и техниками, и всё больше пишется именно на Rust, потому что он ловит целые классы ошибок ещё на этапе компиляции без потери производительности. NVIDIA уже идёт этим путём внутри себя: драйвер Nova для Linux написан на Rust, NVIDIA Dynamo построена на ядре из Rust, у NVTX есть Rust-обвязка.

Чтобы закрыть последний пробел, сами GPU-ядра, NVIDIA выпустила два проекта, каждый под свою из двух существующих в CUDA программных моделей. Первый, cuda-oxide, реализует модель SIMT, ту же, что и в CUDA C++ или numba-cuda: разработчик описывает, что делает один поток, и запускает тысячи таких потоков. Это собственный кодогенерирующий бэкенд для rustc: он перехватывает компиляцию, проводит функции с атрибутом #[kernel] через Rust MIR, IR-фреймворк Pliron и LLVM IR вплоть до PTX, а всё остальное отдаёт стандартному бэкенду компилятора. Для работы нужны Linux, GPU с вычислительной способностью 8.0 или выше, CUDA toolkit версии 12.x или новее, clang с заголовками libclang и закреплённая ночная сборка Rust.

Второй проект, cutile-rs, реализует более новую модель Tile, которая тоже существует в версиях для C++ и Python: в ней описывается, что происходит с одной плиткой (tile) данных, а компилятор Tile IR сам решает, как развернуть это на конкретной архитектуре GPU. NVIDIA рекомендует начинать именно с Tile и переходить на SIMT только тогда, когда нужен ручной контроль над памятью и потоками. Требования у cutile-rs заметно легче: GPU с вычислительной способностью 8.0 или выше, CUDA 13.3, стабильный Rust версии 1.89 или новее и Linux, без ночной сборки и без собственной сборки LLVM. Проект уже опубликован как обычный крейт, который ставится командой cargo add cutile.

Оба проекта показаны на одном и том же примере, поэлементном сложении вектора из 1024 чисел с плавающей точкой, чтобы разницу между подходами было видно на одинаковом коде. Пример на cuda-oxide запускает ядро с 4 блоками по 256 потоков в каждом. Пример на cutile-rs разбивает те же 1024 элемента на 8 плиток по 128 элементов. Оба варианта компилируются, реально исполняются на GPU и печатают одинаковый результат.

Главный технический аргумент, безопасность памяти. Обычная изменяемая ссылка &mut [f32] не подходит для GPU-ядра: всем потокам понадобился бы один и тот же &mut, а это компилятор Rust запрещает. Поэтому в cuda-oxide введён специальный тип DisjointSlice, который выдаёт каждому потоку исключительный доступ ровно к своему элементу и ничему больше; в cutile-rs ту же роль играет разбиение выходного тензора на партиции, каждая плитка получает свой участок памяти, который не пересекается с чужими. В обоих случаях это позволяет переносить на GPU-ядро ту же гарантию отсутствия гонок за память, которую Rust уже даёт для обычного кода на CPU, и ловить ошибки на этапе компиляции, а не в рантайме.

NVIDIA заявляет, что будет развивать и доводить CUDA Rust до зрелости и после 2027 года, и планирует поддержать взаимодействие между языковыми обвязками CUDA, чтобы выбор Rust не запирал разработчика и не отрезал его от существующего кода на C++ и Python, но это пока лишь план, а не готовая возможность.

Ключевые факты

  • NVIDIA выпустила два открытых проекта, cuda-oxide (модель SIMT) и cutile-rs (модель Tile), которые позволяют писать сами GPU-ядра на Rust, а не только запускать их из Rust
  • cuda-oxide, кастомный кодогенерирующий бэкенд для rustc, компилирует Rust-код в PTX через Rust MIR, Pliron и LLVM IR; требует GPU с вычислительной способностью 8.0+, CUDA toolkit 12.x+ и закреплённую ночную сборку Rust
  • cutile-rs работает на уровне плиток данных, публикуется как обычный крейт и требует стабильный Rust 1.89+, CUDA 13.3 и GPU с вычислительной способностью 8.0+, без ночной сборки и без своей сборки LLVM
  • Оба проекта на одном примере, сложении вектора из 1024 чисел, используют типы Rust (DisjointSlice в cuda-oxide, партиционирование тензоров в cutile-rs), чтобы каждый поток или плитка данных получали монопольный доступ к своему участку памяти
  • NVIDIA обещает развивать CUDA Rust и после 2027 года и в перспективе добавить взаимодействие между Rust- и C++/Python-обвязками CUDA, но пока это только план

Почему это важно

Rust уже занял системный слой ИИ-инфраструктуры, движки инференса, серверную обвязку, драйверы, среды выполнения агентов, потому что ловит целые классы ошибок памяти на этапе компиляции без потери скорости. У самой NVIDIA на Rust уже написан драйвер Nova и ядро NVIDIA Dynamo. Но само GPU-ядро оставалось последним местом, куда Rust не дотягивался: его приходилось писать на C++ или Python, даже если весь остальной проект был на Rust. cuda-oxide и cutile-rs закрывают именно этот пробел, позволяя вести весь стек, от хост-кода до GPU-ядра, на одном языке.

Кому это важно

Прежде всего командам, которые уже пишут системный ИИ-софт на Rust, движки инференса, серверную инфраструктуру, среды выполнения агентов, и раньше были вынуждены переключаться на C++ или Python ради самого GPU-кода. Также разработчикам, которые уже используют NVIDIA Dynamo или Nova-драйвер и хотят единообразный стек без смены языка на уровне ядра.

Как это применить

Выбор идёт между двумя моделями CUDA, а не только между языками. SIMT (cuda-oxide) ближе к привычному CUDA C++: поток описывается индивидуально, но нужны Linux, GPU с вычислительной способностью 8.0+, CUDA toolkit 12.x+, clang с libclang и закреплённая ночная сборка Rust, сборка идёт через cargo-oxide, ставится из git-репозитория NVLabs. Tile (cutile-rs), модель, которую NVIDIA советует брать первой: компилятор сам решает, как разложить плитку данных по конкретной архитектуре GPU. Порог входа ниже, стабильный Rust 1.89+, CUDA 13.3, GPU с вычислительной способностью 8.0+, никакой ночной сборки или своей сборки LLVM, проект ставится обычным cargo add cutile.

Можно ли доверять

Это официальный анонс и блог-пост самой NVIDIA с полными рабочими примерами кода: оба демонстрационных проекта, реальные компилируемые программы, которые исполняются на GPU и печатают проверяемый результат. При этом источник не приводит ни одного числа с замерами производительности cuda-oxide или cutile-rs против CUDA C++/Python, не называет конкретного инженера или автора текста и не говорит прямо, готовы ли оба проекта к промышленному использованию, только перечисляет требования к окружению.

Риски и подводные камни

Взаимодействие между Rust-обвязкой CUDA и существующим кодом на C++/Python пока не реализовано, NVIDIA лишь планирует его добавить, а значит выбор Rust сегодня частично изолирует проект от уже написанного на других языках. У cuda-oxide заметно выше порог входа: закреплённая ночная сборка Rust, система LLVM и clang с заголовками libclang, это дальше от обычной Rust-разработки, чем модель Tile. Конкретной даты выхода зрелой версии NVIDIA не называет, только расплывчатое «в 2027 году и далее», и ничего не сообщает про лицензирование или ценообразование самого CUDA toolkit применительно к этим двум трекам.