
🦀 Rust @Nvidia | cuda-oxide author | Proof-oriented programming PS: views are my own.
Bangalore, IN
Joined October 2011
- Tweets1.9K
- Following126
- Followers1.7K
- Likes1.8K
Pinned Tweet
Finally able to talk about what I've been heads-down on for 6 months at @nvidia 🦀⚡
We just open-sourced cuda-oxide — an experimental rustc backend that lets you write CUDA kernels in pure Rust.
No DSLs. No FFI. No source-to-source step. Single source.
Short🧵👇
🤖 Made with AI
Nihal Pasham retweeted
github.com/bitemyapp/inferro…
Research-grade only, but ~182 tokens per second with qwen3 8b w8a8 on an RTX 6000 Pro with all-Rust GPU kernels is nothing to sniff at either.
More to come later on this and some orthogonal things.
Nihal Pasham retweeted
Still on a terminal kick - built a Google Maps renderer in my CLI!
From scratch - single megakernel in Rust/cuda-oxide for rasterization, renders through Kitty graphics.
Nihal Pasham retweeted
#RustChinaConf 2026 x 英伟达
NVIDA 高级软件工程师 Nihal 带来 《cuda-oxide: 用纯 Rust 编写 CUDA 内核》
@npashi
Nihal Pasham retweeted
My favorite talk from Scala Days 2026 was about baking refinement types right into the compiler.
Unlike libraries like Iron or Refined, it adds a built-in solver that verifies logic and math across multiple variables at compile time with zero runtime cost.
Moving from simple checks to full verification is how Scala's type system should evolve to constrain LLMs - AI code won't compile unless the math holds up.
Nihal Pasham retweeted
The latest Burn release includes a migration of CubeCL's compiler infrastructure to use pliron!
github.com/tracel-ai/cubecl/…
It's nice to see pliron being adopted by Rust compiler projects, with both CubeCL and cuda-oxide now building on it.
Nihal Pasham retweeted
Start learning GPU programming with one fully animated YouTube lecture.
youtu.be/dEZP1qUNTOk
This is the first video of my GPU programming series with Triton.
Every idea in it is visual and animated, just like the GIF in this post, but for a full hour.
You write c = a + b in PyTorch every day.
This lecture shows what the GPU actually does with it.
𝐖𝐡𝐚𝐭 𝐭𝐡𝐞 𝐥𝐞𝐜𝐭𝐮𝐫𝐞 𝐜𝐨𝐯𝐞𝐫𝐬
- How a GPU sits inside your computer: PCIe, NVLink, servers and clusters
- Inside an NVIDIA H100: SMs, FP32 lanes, the warp scheduler, tensor cores, shared memory
- Threads, warps, blocks and grids, and how each thread finds its element
- Memory: SRAM vs DRAM, DDR vs GDDR vs HBM, caches, latency vs bandwidth
- Making memory fast: latency hiding, coalescing and kernel fusion
- Why Triton exists, and how it lets you think in tiles instead of threads
- Memory-bound vs compute-bound, arithmetic intensity and the roofline
- Attention, the N x N matrix, and how FlashAttention fixes it
No CUDA or hardware background needed.
I want to make more long-form technical animated videos, something similar to what @neural_avb does.
Taken inspiration from him
𝐖𝐡𝐚𝐭'𝐬 𝐧𝐞𝐱𝐭
- Lecture 2: writing our first Triton kernel, vector add, line by line, will post it in few days
- More lectures on GPU programming and inference optimization
- A planned series on deep learning for audio
Subscribe to the channel so you don't miss them.
Please also share the video with your ML and DL friends, or in any study or community groups you're part of.
Watch the full lecture:
youtu.be/dEZP1qUNTOk
If you are into audio deep learning, inference, or Triton, follow @Mayank_022 me.
I will be uploading more posts related to that.
🦀 A question I keep getting: “How do I get started with cuda-oxide?”
With, Rust, GPUs, and compilers, it can be a lot to take in.
Here’s my attempt to make it easier: a simple Rust GPU kernel, what #[kernel] generates, and how the host launches it.
We’ll cover:
• 🗺️ Finding your way around the repo
• 🔍 What happens behind #[kernel]
• 🚀 How the host launches your GPU kernel
youtu.be/3X_x0MfN90Q?si=fRZZ…
Nihal Pasham retweeted
The allocator_api feature has been stabilized!
> Rust’s Allocator API standardizes custom memory allocation, enabling collections to use specialized strategies for better control, performance, and memory efficiency.
I'd say .. super excited for .. 🦀 + 🐍
PS: If you're in town, drop by.
𝐑𝐞𝐠𝐢𝐬𝐭𝐞𝐫 𝐡𝐞𝐫𝐞: meetup.com/bangpypers/events…
@rustaceans_rs @RustLondon_
Next up at BangPypers × @IndiaRust:
@npashi — cuda-oxide: Write CUDA (SIMT) kernels in pure Rust
A look at using Rust for CUDA GPU kernels and systems-level GPU programming.
📅 Sept 19
📍 Rippling, Bengaluru
Project: github.com/NVlabs/cuda-oxide
#Rust #CUDA #GPU
🎉 CUDA Rust is here! Team 🟩 ❤️ 🦀
You can now write CUDA kernels in plain Rust, two ways: cuda-oxide (SIMT) and cutile-rs (Tile).
developer.nvidia.com/blog/in…
PS: If you're at @rust_foundation's #RustConf2026 in Montréal, catch Melih Elibol's talk "Fearless Concurrency on the GPU" — and grab anyone from @nvidia there to learn more.
Nihal Pasham retweeted
Exciting day for NVIDIA and @huggingface.
Open models strengthen safety and cybersecurity, accelerate innovation and diffusion, and enable sovereignty. They allow every developer, startup, university, industry and country to build with, customize and benefit from AI.
Thank you @ClementDelangue for coming to me.
NVIDIA is going to be a great home for Hugging Face, its community and the future of open models. 🤗
blogs.nvidia.com/blog/nvidia…
Nihal Pasham retweeted
everyone should go read @dwarkesh_sp’s post - it does a great job of laying out the timeline and what we know ( and don’t know)
I do have two issues with it
A) the use of anthropomorphic language. These are not civilizations nor do they have desires just like a CPU thread or a bunch of programs don’t. this doesn’t mean we downplay the importance of this moment for cyber - but using human parallels for what I believe is code is dangerous territory.
B) IMO it gets the impact of open source models wrong and is unreasonably dismissive for reasons that are not clear. As @ClementDelangue highlights below HF was blocked from using closed models to analyze what was happening and had to turn to open weight models to help them make sense of it.
This is a very key moment for how we think about intelligence and cyber and every bit of extra understanding and clarity helps.
Nihal Pasham retweeted
Vibe-trained a humanoid control in pure Rust 🎈
- Built a whole new Rust GPU Simulator named Nexus: github.com/dimforge/nexus independent from Mujoco, Isaac, Genesis adding a physics data point for Sim2Sim
- Built a whole new Rust RL Training pipeline named Zealot: github.com/haixuanTao/zealot independent from Torch, Gym, ...
- 2x Faster than the reference @nvidia /WBC-Agile: github.com/nvidia-isaac/WBC-…
- Use less RAM and VRAM fitting in less powerful GPUs 🎉
This happens to be the last project, as 1ms.ai 🥲 Follow up to see what's coming next!
#ai #robotics #sim #rust
The future of AI codegen is to let models evolve their compiler harness, creating & evolving the tools and abstractions for best performance via experimentation. The CAKE work is demonstrating that beautifully - producing SoTA kernels with practical impact. Awesome work team!
🍰 CAKE paper's out, the design bet: the compiler isn't a fixed black box the agent calls — it's part of the harness, and it's under evolution too.
CAKE didn't inherit existing abstraction layer. no tile/layout abstractions: the vocabulary was distilled by agents from a corpus of production kernels. every pattern the agent couldn't express pushed new primitives into the IR, and the analyses to keep them checkable. every barrier/layout bug that kept coming back became a verifier rule.
none of this can be designed up front. the IR has to co-evolve with the kernels, and the workload tells you what's missing, the corpus tells you if the fix broke anything.
the best language for an agent is the one that tells you what's illegal, what's slow, and which decision might made it faster.
arxiv.org/abs/2608.12629
New video 🦀⚡ Safe Rust's bounds checks on the GPU. Can we elide it?
Safe Rust bounds-checks every slice index. In a GEMM hot loop that's a 2.4x perf tax, and LLVM can't remove it for you: the proof the buffers are big enough lives in your host code, not the IR.
Produces the same machine code as the hand-written unsafe version and its zero-cost safety abstraction.
@AstraKernel @rustoftheday @rustaceans_rs @ThisWeekInRust
cuda-oxide now hands that proof to the compiler:
🤝 launch contracts: sizes proven once per launch
🔍 proof-carrying views: one check per row/column
⚖️ 2,942 → 7,159 GFLOPS (2.43x), bit-identical
🚪 escape hatch: #[kernel(unchecked_indexing)]
youtu.be/raXWK8-IWCc?si=nfdo…




















