gik|iewicz

Nvidia oficjalnie zapowiedziała CUDA Rust – zestaw narzędzi pozwalających pisać kernele GPU natywnie w Rust, a nie tylko uruchamiać je z poziomu tego języka. Ogłoszenie pojawiło się na koncie NVIDIA HPC Developer i zostało opisane m.in. na blogu technicznym Nvidii oraz w serwisach branżowych. Firma proponuje dwie ścieżki: kompilator cuda-oxide oraz bibliotekę cutile-rs działającą na stabilnym Rustcie.

TL;DR: Nvidia ogłosiła CUDA Rust – dwa projekty do natywnego pisania kerneli GPU w Rust. cuda-oxide to ścieżka dla kerneli SIMT kompilowanych bezpośrednio do PTX, a cutile-rs oferuje programowanie oparte na kafelkach (tiles) na stabilnym Rustcie. Oba projekty rozszerzają model własności Rusta na GPU, dzięki czemu błędy aliasingu da się wyłapać już w czasie kompilacji, a nie podczas uruchomienia.

Co dokładnie ogłosiła Nvidia we wrześniu 2026?

Nvidia zapowiedziała CUDA Rust, czyli możliwość pisania kerneli GPU bezpośrednio w Rust z kompilacją natywną do PTX. Ogłoszenie z września 2026 przedstawia dwa równoległe projekty: cuda-oxide oraz cutile-rs. Serwis cloudnews.tech opisuje je jako dwa eksperymentalne sposoby pisania kerneli CUDA bez opuszczania języka Rust.

To nie jest biblioteka do wywoływania gotowych kerneli. Chodzi o pełny łańcuch: kod pisany w Rust trafia do PTX, czyli formatu pośredniego wykonywalnego na GPU Nvidii. Hiszpański serwis źródło – język coraz mocniej wchodzi w obszar obliczeń przyspieszanych.

Czym jest cuda-oxide i dla kogo jest przeznaczone?

Skierowane jest do programistów, którzy chcą pełnej kontroli nad wątkami i blokami – a więc do osób piszących kernela od zera. Materiał pokazany przy ogłoszeniu ilustruje to przykładem vecadd, gdzie atrybuty takie jak #[kernel], #[launch_bounds(256)] czy #[launch_contract(domain = 1, block = (256, 1, 1))] opisują punkt wejścia na GPU oraz budżet wątków dla kompilatora. Funkcja przyjmuje wycinki f32 oraz DisjointSlice<f32> dla wyniku.

Właśnie DisjointSlice jest tu istotny – typ gwarantuje rozłączność zapisów, więc kompilator może sprawdzić poprawność aliasingu z góry.

Dla kogo to nie jest: dla kogoś, kto chce jedynie szybko wywołać gotowy kernel bez znajomości modelu SIMT. W takim przypadku bliżej mu do drugiej ścieżki.

Co oferuje cutile-rs i dlaczego działa na stabilnym Rustcie?

cutile-rs to druga ścieżka CUDA Rust, oparta na programowaniu kafelkowym (tile-based). Blog techniczny Nvidii opisuje cuTile Rust jako system do bezpiecznego, idiomatycznego tworzenia kerneli GPU w Rust, który rozciąga model własności języka na kernele kafelkowe i dzieli mutowalne wyniki na rozłączne fragmenty.

Główna różnica względem cuda-oxide polega na poziomie abstrakcji. Zamiast zarządzać pojedynczymi wątkami, programista operuje kafelkami danych. Serwis aiposthub wskazuje, że biblioteka wymaga stabilnej wersji Rusta 1.89 lub nowszej, a bezpieczeństwo wynika z podziału tensorów przez własność rozłącznych wycinków.

Działa to zatem na stabilnym toolchainie – bez nightly. Dla zespołów produkcyjnych ta okoliczność bywa rozstrzygająca, bo utrzymanie kodu na kompilatorze nightly generuje realne koszty.

Podsumowując tę część: obie ścieżki prowadzą do tego samego celu, różni je głównie granica abstrakcji oraz wymagania wobec kompilatora. Osobom zaczynającym od zera rekomenduję przejrzenie obu przykładów przed wyborem – natomiast o tym, jak te projekty wypadają w szczegółach technicznych, piszę w drugiej części artykułu, wraz z omówieniem kontekstu całego ekosystemu, o którym morela była mowa przy okazji NVIDIA GTC 2026.

• cuda-oxide: kernele SIMT, bezpośrednia generacja PTX, pełna kontrola nad wątkami
• cutile-rs: model kafelkowy, stabilny Rust 1.89+, podział tensorów przez własność
• Oba projekty: wyłapywanie błędów aliasingu w czasie kompilacji
• Wspólny cel: pisanie kerneli bez opuszczania Rusta

Jak DisjointSlice i model własności eliminują wyścigi danych na GPU?

DisjointSlice to typ z przykładów cuda-oxide, który gwarantuje rozłączność zapisów do pamięci. Kiedy kernel zapisuje wyniki do wycinka tego typu, kompilator wie, że żaden inny fragment kodu nie odwołuje się w tym czasie do tego samego bufora. Wyścig danych staje się wtedy błędem kompilacji, a nie awarią w trakcie działania na GPU.

Mechanizm opiera się na rozciąganiu modelu własności Rusta na kernele. Zamiast surowych wskaźników, których poprawność programista sprawdza ręcznie, API wymaga typów z gwarancjami rozłączności.

W praktyce oznacza to zmianę momentu, w którym błąd wychodzi na jaw. Klasycznie nieprawidłowy wskaźnik w kernelu dawał awarie w runtime, trudne do zdiagnozowania. W CUDA Rust ta sama klasa błędu jest odfiltrowywana przed uruchomieniem programu na karcie. To ta sama filozofia, o której pisałem przy okazji tekstu Błędy, których Rust nie wyłapie – borchecker łapie wiele problemów, ale nie wszystkie, dlatego rozszerzenie gwarancji na kod GPU jest istotnym krokiem.

• własność buforów przenoszona do kernela
• rozłączność zapisów sprawdzana przez typ DisjointSlice
• błędy aliasingu wychwytywane przed uruchomieniem
• brak potrzeby ręcznego pilnowania niezmienności buforów

Co pokazuje przykład kernela vecadd z ogłoszenia?

Przykład vecadd ilustruje, jak wygląda punkt wejścia kernela w cuda-oxide. Dzięki launch_contract(domain = 1, block = (256, 1, 1)) kod jawnie deklaruje, że indeksowanie odbywa się w 1-D, a blok ma 256 wątków.

Atrybuty niosą konkretną funkcję. #[kernel] oznacza punkt wejścia na GPU, #[launch_bounds(256)] określa maksymalną liczbę wątków na blok i pozwala kompilatorowi zaplanować budżet, a #[launch_contract] opisuje kontrakt uruchomienia. Wobec tego informacja, którą w C++ CUDA przekazuje się zewnętrznie, tutaj staje się częścią sygnatury funkcji w Rust.

Zdjęcie kodu z ogłoszenia pokazuje również komentarze dokumentujące każdy atrybut, co sugeruje, że przykład ma charakter dydaktyczny. Choć materiał wizualny nie pozwala zweryfikować całego toolchaina, sama struktura przykładu jest spójna z opisami tekstowymi: kernel pisany idiomatycznie w Rust, z typami bezpiecznymi i jawnym kontraktem launchowania.

Na przykład taki zapis sprawia, że błędna konfiguracja bloków jest widoczna w sygnaturze, a nie ukryta w kodzie wywołującym. Dla zespołów utrzymujących duże kernela to realna zmiana w sposobie pracy.

Jak wygląda tłumaczenie operacji cuTile z Pythona na Rust?

Blog techniczny Nvidii opisuje przepływ pracy z użyciem agentowego AI, który służy do tłumaczenia operacji cuTile z Pythona na Rust. Tytuł materiału wskazuje wprost na scenariusz: istniejący kod oparty na cuTile w Pythonie może zostać przeniesiony do cuTile Rust, czyli kafelkowego systemu do bezpiecznego tworzenia kerneli w Rust.

Materiał podkreśla, że cuTile Rust rozciąga model własności na kernele kafelkowe i dzieli mutowalne wyniki na rozłączne fragmenty. Dzięki temu przenoszone operacje zachowują gwarancje bezpieczeństwa pamięci, które w wersji Pythonowej nie były egzekwowane przez kompilator. Z kolei cutile-rs działa na stabilnym Rustcie 1.89 lub nowszym, więc wynik tłumaczenia nie wymaga toolchaina nightly.

Dla zespołów z istniejącym kodem cuTile Pythonowym jest to ścieżka migracji, a nie konieczność pisania od zera. Warto jednak zaznaczyć, że źródła nie opisują szczegółów samego narzędzia tłumaczącego, na przykład zakresu wspieranych operacji ani stopnia automatyzacji. Moim zdaniem to element ekosystemu, który zasługuje na obserwację, bo łączy dwa nurty widoczne na NVIDIA GTC 2026 – agentowe AI w przepływach developerskich oraz rosnącą rolę Rusta w infrastrukturze obliczeń, o czym pisał też tekst Rewriting Bun in Rust.

Czy cuda-oxide i cutile-rs są już gotowe do produkcji?

Na podstawie dostępnych źródeł oba projekty należy traktować jako wczesne ścieżki, a nie dojrzałe narzędzia produkcyjne.

Nie oznacza to, że projekty są zabawkami. cutile-rs wymaga stabilnej wersji Rusta 1.89 lub nowszej, co ułatwia eksperymenty bez dotykania nightly. Jednakże brak potwierdzonej wersji stabilnej oznacza, że opieranie na nich kodu produkcyjnego niesie ryzyko zmian w API.

Co można zrobić już dziś?

• obserwować repozytoria obu projektów i blog techniczny Nvidii
• przetestować przykład vecadd w cuda-oxide w izolowanym środowisku
• ocenić cutile-rs dla istniejących operacji kafelkowych na stabilnym Rustcie
• śledzić materiał o tłumaczeniu cuTile z Pythona na Rust
• porównać oba podejścia na własnych przypadkach użycia

Do czasu ogłoszenia dostępności ogólnej rekomendacją jest traktowanie CUDA Rust jako technologii do eksploracji i prototypów, a nie fundamentu dla systemów krytycznych.

Co to oznacza dla ekosystemu Rust i programowania GPU?

Oficjalne wsparcie Nvidii przesuwa Rust z roli języka wywołującego kernele do roli języka, w którym kernele się pisze. Revista Cloud opisuje to jako krok ku uczynieniu z Rusta języka pierwszej klasy w ekosystemie CUDA. Dla języka, który dotychczas w obszarze GPU bazował głównie na inicjatywach społeczności, oficjalna ścieżka od największego producenta GPU ma duże znaczenie symboliczne i praktyczne.

Zmienia się także rachunek ekonomiczny dla zespołów. Jeżeli błędy aliasingu są wyłapywane w czasie kompilacji, koszt debugowania kerneli spada, a przenoszenie modelu własności na GPU skraca cykl testowania. Z tego powodu zespoły piszące dziś w C++ CUDA mogą rozważyć stopniowe przenoszenie fragmentów kodu, choć brak statusu stabilnego ogranicza tempo takich decyzji.

Warto też widzieć ogłoszenie w kontekście szerszego trendu opisanego w tekście Rust w 2026: Od System Programming do AI/ML – język coraz mocniej wchodzi w obszar obliczeń przyspieszanych i infrastruktury AI. Pytaniem na najbliższe miesiące pozostaje, czy społeczność przyjmie te narzędzia na dużą skalę, oraz jak szybko pojawią się wersje stabilne. Na razie źródła nie podają harmonogramu, więc obserwacja repozytoriów pozostaje najlepszym źródłem informacji o kierunku rozwoju.

Często zadawane pytania

Czym różni się cuda-oxide od cutile-rs?

cutile-rs z kolei oferuje programowanie kafelkowe (tile-based) i działa na stabilnym Rustcie 1.89 lub nowszym. Różnica sprowadza się do poziomu abstrakcji: wątki versus kafelki danych oraz wymagania wobec toolchaina.

Czy CUDA Rust wymaga nightly Rusta?

Nie w obu przypadkach tak samo. cutile-rs działa na stabilnej wersji Rusta 1.89 lub nowszej, więc nie wymaga toolchaina nightly. W przypadku cutile-rs mechanizm opiera się na dzieleniu mutowalnych wyników na rozłączne fragmenty, a w cuda-oxide na typie DisjointSlice, który gwarantuje rozłączność zapisów. Dzięki temu wyścigi danych oraz niezdefiniowane zachowanie wynikające z nakładających się zapisów są odfiltrowywane przed uruchomieniem kernela na GPU.

Czy CUDA Rust jest już stabilny i gotowy do użycia produkcyjnego?

Źródła opisują cuda-oxide i cutile-rs jako dwa eksperymentalne lub początkowe sposoby pisania kerneli GPU w Rust.

Podsumowanie

Ogłoszenie CUDA Rust przynosi kilka konkretnych wniosków:

• Nvidia oficjalnie wspiera pisanie kerneli GPU natywnie w Rust, z kompilacją do PTX
• cuda-oxide oferuje kernele SIMT z pełną kontrolą nad wątkami i blokami
• cutile-rs zapewnia programowanie kafelkowe na stabilnym Rustcie 1.89+
• Model własności Rusta rozciąga się na GPU, więc błędy aliasingu wychodzą w czasie kompilacji
• Oba projekty są wciąż wczesnymi ścieżkami, bez potwierdzonego harmonogramu stabilizacji

Jeśli temat Cię zaciekawił, obserwuj repozytoria obu projektów oraz blog techniczny Nvidii, a następnie sprawdź przykłady na własnym sprzęcie. Warto też sięgnąć po wcześniejsze teksty o ekosystemie Rust i GPU na blogu, bo to obszar, który będzie się szybko rozwijał w kolejnych miesiącach.