🦀 Rust Just Achieved Async/Await on GPUs
Today’s issue: The Rust Spellbook, Your Lightweight Wayland Launcher That Actually Launches Fast, and One Clean, No-BS Page of Async Rust.
Hello Rustaceans!
Last week was RustNation UK in London, and the Rust community showed up in force. I wish I could have been there with you. To everyone who made the trip, hope you had an absolute blast.
In this issue, we’ll discuss the recent breakthrough of Async/await on the GPU, present a Rust tip to you, spotlight an amazing project, and share 10 incredible links of the week.
Here’s issue 107.
MAIN NEWS
Rust Just Achieved Async/Await on GPUs
VectorWare just pulled off a world-first: compiling and executing Rust’s async/await directly on the GPU, complete with executors like Embassy.
No DSL. No custom pseudo-language. Just pure Rust concurrency running inside GPU kernels.
Traditional GPU programming is largely built around: data-parallel kernels, manual synchronization, explicit thread coordination, and low-level control over memory and execution
Once workloads become complex, conditional logic, multi-step pipelines, or interdependent tasks, GPU programming quickly turns into manual orchestration of threads and synchronization barriers. It’s powerful, but brittle and error-prone.
What VectorWare Did
The team built an execution model that allows: async functions inside GPU kernels, await chaining directly in PTX-executed code, support for futures combinators (futures_util), and task interleaving without an operating system
They started with a blocking executor proof-of-concept to validate feasibility.
Then they ported Embassy, the no_std async runtime from embedded systems with minimal modification.
The result? Concurrent tasks running on GPUs, cooperative scheduling, shared Rust async abstractions between CPU and GPU.
Your existing async patterns can, in theory, compose across execution environments. That’s a big shift in code reuse.
What This Unlocks
This approach could impact: ML pipelines, scientific simulations, high-performance compute workloads, and GPU-heavy async data processing.
Instead of rewriting logic for GPU-specific frameworks, you can potentially reuse Rust async code with GPU execution.
This is still emerging technology with clear trade-offs. Cooperative scheduling introduces the risk of task starvation, and the absence of hardware interrupts means polling overhead remains a concern.
Increased register pressure may also reduce GPU occupancy, and runtime ergonomics are still evolving.
The team has hinted at future improvements including GPU-native executors, further runtime refinements, and broader standard library integration. It remains experimental, but architecturally significant.
Huge credit to the VectorWare team for pushing the boundaries here, especially Christian, Nicholas, Eddyb, and FractalFir. You folks are making GPU Rust dreams real.
RUST TIP 🦀
Last week we shared a tip on how to use matches! for fast, readable pattern checks.
This week’s tip is from John Arundel, Rust teacher and author of The Rust Spellbook. Rust Bytes readers get 10% off with code BYTES26.
Prefer From/TryFrom over as
Using as for numeric conversions can silently truncate values when the destination type is smaller. That’s rarely what you want.
For infallible conversions, use From:
If this compiles, the conversion is guaranteed to be sound. Rust won’t let you accidentally convert a larger type into a smaller one.
For conversions that may or may not succeed depending on the value, use TryFrom:
TryFrom returns a Result:Ok if the value fits, Err if it doesn’t.
Avoid as when correctness matters. Make the possibility of failure explicit.
You can run the code on Rust Playground.
PROJECT SPOTLIGHT 💡
Coffee
Coffee is an opinionated 2D game engine for Rust focused on simplicity, explicitness, and type-safety.
Built by a dev who was just trying to ship a game, it hands you an API that’s explicit, type-safe, and refreshingly opinionated.
Why it’s worth your attention:
Deterministic fixed timestep, no “why is physics drunk?” moments.
Declarative, type-safe loading screens with built-in progress tracking.
Built-in debug view. performance metrics without bolting on extra tooling.
Multiplatform graphics backends. OpenGL, Vulkan, Metal, D3D11/12. Pick your poison.
Yes, it’s early-stage. Yes, things can change. But if you like living slightly on the edge, it’s a solid playground.
Coffee is open-source on GitHub at https://github.com/hecrj/coffee.
AWESOME LINKS OF THE WEEK 🔗
The Cargo Team published This Development-cycle in Cargo: 1.94. The Rust mentorship team also announced participation opportunities for Google Summer of Code 2026.
BoltFFI is a high-performance multi-language bindings generator for Rust. Up to 1,000x faster than UniFFI, and up to 450x faster than wasm-bindgen.
Dmitry Kudryavtsev explains why he’s leaving Rust for Node.js. Spoiler: sometimes you just want your build to finish before your coffee gets cold.
The talented Rustaceans at NearAI have released ironclaw, an OpenClaw inspired implementation in Rust focused on privacy and security.
DuckDB is hiring a full-time Rust engineer in Amsterdam. Apply. And if you land the gig, come back and flex a little, we’ll be pretending we knew you before you were cool.
Gio wrote about why you should parse inputs to strong types like NonZeroF32 early for encoding invariants, making illegal states unrepresentable and avoiding runtime validations.
Kamran Tahir built an open-source Rust Postgres extension pg_strict to block unsafe UPDATE/DELETE without WHERE clauses, detailing build challenges and optimal hooks integration.
Tony Finch just casually hand-rolled a minimal async Rust executor, complete with fake time and custom wakers. Because apparently using an existing runtime would’ve been too easy.
Rust India Conference 2026 CFP is open, if you’ve got battle-tested industrial Rust stories, send them in before 31 Mar.
José Richiez just released Lucien, a lightweight app launcher written in Rust and built specifically for Wayland.
CodeCrafters: Become a Better Rust Engineer
CodeCrafters created amazing Rust courses that push your skills beyond the basics.
You’ll have fun building real-world projects from scratch, including Git, Docker, Redis, Kafka, SQLite, Grep, BitTorrent, HTTP Server, an Interpreter, and DNS.
The courses are self-paced, so you can learn at your own speed.
Join for free and get 40% off when you upgrade. [affiliate]
SUPPORT RUST BYTES
You’re Rust Bytes’ biggest fans, and we love to see it.
❤️ Recommend Rust Bytes to your friends.
🤳 Connect with us on our socials: X, BlueSky, Mastodon, LinkedIn.
☕️ Buy our editors coffee.
📨 Email us at rustaceanseditors@gmail.com for sponsorship, feedback or ideas.
Wishing you a good week ahead. If you see this, please say hi!
That's all for now, Rustaceans.
John & Elley.