--- title: Introducing CUDA Rust: Two Tracks for Writing GPU Kernels description: NVIDIA introduced native GPU kernel programming in Rust through two open-source projects announced in September 2026: cuda-oxide for the SIMT model (a custom... canonical: https://daily.dev/posts/introducing-cuda-rust-two-tracks-for-writing-gpu-kernels-a7096aegg twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: Introducing CUDA Rust: Two Tracks for Writing GPU Kernels | daily.dev og:description: NVIDIA introduced native GPU kernel programming in Rust through two open-source projects announced in September 2026: cuda-oxide for the SIMT model (a custom... og:url: https://daily.dev/posts/introducing-cuda-rust-two-tracks-for-writing-gpu-kernels-a7096aegg og:image: https://api.daily.dev/og/posts/A7096AEGG.png og:image:alt: Introducing CUDA Rust: Two Tracks for Writing GPU Kernels og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # Introducing CUDA Rust: Two Tracks for Writing GPU Kernels **[NVIDIA Developer](https://daily.dev/sources/nvidiadev)** · 13 min read · 49 upvotes · 4 comments ## Summary NVIDIA introduced native GPU kernel programming in Rust through two open-source projects announced in September 2026: cuda-oxide for the SIMT model (a custom rustc codegen backend compiling Rust MIR through LLVM to PTX, requiring a pinned nightly toolchain) and cutile-rs for the newer Tile model (published on crates.io, works on stable Rust 1.89+, JIT-compiles kernel ASTs through CUDA Tile IR). Both let developers write GPU kernels directly in Rust rather than wrapping code written in another language, and both leverage Rust's ownership system to catch memory aliasing bugs at compile time instead of at runtime. cutile-rs is already used outside NVIDIA in HuggingFace's Grout and in mistral.rs, while cuda-oxide remains early alpha. NVIDIA plans to keep maturing both into 2027, alongside existing community projects like Rust-GPU, rust-cuda, and CubeCL. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Questions this post answers ### Can I write CUDA GPU kernels natively in Rust instead of C++ or Python? Yes, NVIDIA released two open source projects that compile Rust directly to PTX for GPU kernels: cuda-oxide for the SIMT model and cutile-rs for the newer Tile model. Previously, kernel code itself had to be written in CUDA C++ or numba-cuda even when the rest of the stack was Rust; these projects close that gap by compiling kernel bodies natively from Rust. _Developers weighing native Rust GPU kernels can track how cuda-oxide and cutile-rs mature on daily.dev._ ### What is the difference between cuda-oxide and cutile-rs for Rust GPU programming? cuda-oxide targets the SIMT model, the same one used in CUDA C++, requiring a pinned Rust nightly toolchain, clang, and compute capability 8.0 or later; it is early alpha. cutile-rs targets the newer Tile model where code describes what one tile of data does rather than one thread, runs on stable Rust 1.89+ with CUDA 13.3, needs no nightly toolchain or local LLVM, and is further along, already used in HuggingFace's Grout and mistral.rs. _Teams choosing between SIMT and Tile programming models for GPU kernels can follow updates on daily.dev._ ### How does Rust's ownership system prevent GPU memory race conditions in CUDA kernels? Rust's borrow checker catches aliasing bugs, such as passing the same buffer as both an input and mutable output, at compile time instead of letting them surface as intermittent runtime races. In cuda-oxide, a DisjointSlice type gives each thread exclusive access to its own element, and passing an output buffer as an input fails with a borrow-checker error. In cutile-rs, ownership tracking across the launch boundary rejects aliased tensors with a moved-value error, which is described as the stronger of the two safety guarantees. _Developers hunting hard-to-reproduce GPU race conditions can track compile-time safety approaches like this on daily.dev._ ## Community discussion Top comments from developers on daily.dev. **@petecapecod** · 4 upvotes > Sweet it's getting Rusty up in here. Cool addition **@kelvin\_lima** · 2 upvotes > Writing GPU kernels directly in Rust with compile-time memory safety checks sounds like a huge step forward, but having two separate tracks from NVIDIA feels more like they're hedging their bets than committing to a clear direction. **@5awtooth** · 1 upvotes > I was able to reverse engineer these and unlock nvFortran on windows using Zig to write PTX, works great. **@agustinbarrientos** · 0 upvotes > Between the two, I'd choose Tile unless I really needed SIMT control and could tolerate a pinned nightly --- Tags: [#rust](https://daily.dev/tags/rust), [#nvidia](https://daily.dev/tags/nvidia), [#gpu](https://daily.dev/tags/gpu), [#cuda](https://daily.dev/tags/cuda) [View this post on daily.dev](https://daily.dev/posts/introducing-cuda-rust-two-tracks-for-writing-gpu-kernels-a7096aegg) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"Introducing CUDA Rust: Two Tracks for Writing GPU Kernels","url":"https://daily.dev/posts/introducing-cuda-rust-two-tracks-for-writing-gpu-kernels-a7096aegg","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/introducing-cuda-rust-two-tracks-for-writing-gpu-kernels-a7096aegg"},"datePublished":"2026-09-08T12:05:29.951Z","dateModified":"2026-09-14T08:10:08.157Z","description":"NVIDIA introduced native GPU kernel programming in Rust through two open-source projects announced in September 2026: cuda-oxide for the SIMT model (a custom...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/276fdbd310287f17cbf769a700f46072?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/276fdbd310287f17cbf769a700f46072?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"NVIDIA Developer","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"NVIDIA Developer","logo":"https://media.daily.dev/image/upload/t_logo,f_auto/v1/logos/86e45aab42ba48ce83103d01b1119910","url":"https://daily.dev/sources/nvidiadev"},"commentCount":4,"discussionUrl":"https://daily.dev/posts/introducing-cuda-rust-two-tracks-for-writing-gpu-kernels-a7096aegg","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":49},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":4}],"keywords":"rust,nvidia,gpu,cuda","timeRequired":"PT13M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"NVIDIA Developer","item":"https://daily.dev/sources/nvidiadev"},{"@type":"ListItem","position":3,"name":"Introducing CUDA Rust: Two Tracks for Writing GPU Kernels"}]} {"@context":"https://schema.org","@type":"WebPage","@id":"https://daily.dev/posts/introducing-cuda-rust-two-tracks-for-writing-gpu-kernels-a7096aegg","comment":[{"@type":"Comment","text":"Sweet it’s getting Rusty up in here. Cool addition","datePublished":"2026-09-08T12:42:38.149Z","url":"https://daily.dev/posts/A7096AEGG#c-IlaWjXOq7","author":{"@type":"Person","name":"Peter Cruckshank","url":"https://daily.dev/petecapecod","image":"https://media.daily.dev/image/upload/s--ZJhQyKws--/f_auto/v1721235024/avatars/avatar_A9xh33q0QoxtkGoJRCosp"},"interactionStatistic":{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":4}},{"@type":"Comment","text":"Writing GPU kernels directly in Rust with compile-time memory safety checks sounds like a huge step forward, but having two separate tracks from NVIDIA feels more like they’re hedging their bets than committing to a clear direction.","datePublished":"2026-09-09T12:41:37.701Z","url":"https://daily.dev/posts/A7096AEGG#c-DUDukPsCe","author":{"@type":"Person","name":"Kelvin Lima","url":"https://daily.dev/kelvin_lima","image":"https://media.daily.dev/image/upload/s--aETMiQc5--/f_auto/v1787513560/avatars/avatar_asGeTu7mKynRnhXcOxYVt?_a=BAMAMicg0"},"interactionStatistic":{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":2}},{"@type":"Comment","text":"I was able to reverse engineer these and unlock nvFortran on windows using Zig to write PTX, works great.","datePublished":"2026-09-10T03:23:51.830Z","url":"https://daily.dev/posts/A7096AEGG#c-LY9obVhLZ","author":{"@type":"Person","name":"David Clabaugh","url":"https://daily.dev/5awtooth","image":"https://avatars.githubusercontent.com/u/8500545?v=4"},"interactionStatistic":{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":1}},{"@type":"Comment","text":"Between the two, I’d choose Tile unless I really needed SIMT control and could tolerate a pinned nightly","datePublished":"2026-09-10T02:20:37.020Z","url":"https://daily.dev/posts/A7096AEGG#c-gM4LGUJX9","author":{"@type":"Person","name":"Agustin Barrientos","url":"https://daily.dev/agustinbarrientos","image":"https://media.daily.dev/image/upload/s--5ayxQnqn--/f_auto/v1788281802/avatars/avatar_wQYYVe5Tbj0NJ7C7qPoa8?_a=BAMAMicg0"}}]} {"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/introducing-cuda-rust-two-tracks-for-writing-gpu-kernels-a7096aegg#faq","mainEntity":[{"@type":"Question","name":"Can I write CUDA GPU kernels natively in Rust instead of C++ or Python?","acceptedAnswer":{"@type":"Answer","text":"Yes, NVIDIA released two open source projects that compile Rust directly to PTX for GPU kernels: cuda-oxide for the SIMT model and cutile-rs for the newer Tile model. Previously, kernel code itself had to be written in CUDA C++ or numba-cuda even when the rest of the stack was Rust; these projects close that gap by compiling kernel bodies natively from Rust. Developers weighing native Rust GPU kernels can track how cuda-oxide and cutile-rs mature on daily.dev."}},{"@type":"Question","name":"What is the difference between cuda-oxide and cutile-rs for Rust GPU programming?","acceptedAnswer":{"@type":"Answer","text":"cuda-oxide targets the SIMT model, the same one used in CUDA C++, requiring a pinned Rust nightly toolchain, clang, and compute capability 8.0 or later; it is early alpha. cutile-rs targets the newer Tile model where code describes what one tile of data does rather than one thread, runs on stable Rust 1.89+ with CUDA 13.3, needs no nightly toolchain or local LLVM, and is further along, already used in HuggingFace's Grout and mistral.rs. Teams choosing between SIMT and Tile programming models for GPU kernels can follow updates on daily.dev."}},{"@type":"Question","name":"How does Rust's ownership system prevent GPU memory race conditions in CUDA kernels?","acceptedAnswer":{"@type":"Answer","text":"Rust's borrow checker catches aliasing bugs, such as passing the same buffer as both an input and mutable output, at compile time instead of letting them surface as intermittent runtime races. In cuda-oxide, a DisjointSlice type gives each thread exclusive access to its own element, and passing an output buffer as an input fails with a borrow-checker error. In cutile-rs, ownership tracking across the launch boundary rejects aliased tensors with a moved-value error, which is described as the stronger of the two safety guarantees. Developers hunting hard-to-reproduce GPU race conditions can track compile-time safety approaches like this on daily.dev."}}]} ```