--- title: Offloading Rust To GPUs Proves Capable Of High... description: A research paper from Manuel S. Drehwald, Marcelo Domínguez, Kevin Sala, Alán Aspuru-Guzik, and Johannes Doerfert explores using LLVM's Offload infrastructure... canonical: https://daily.dev/posts/offloading-rust-to-gpus-proves-capable-of-high-performance-with-memory-safety-6ojskq9d9 twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: Offloading Rust To GPUs Proves Capable Of High Performance With Memory Safety | daily.dev og:description: A research paper from Manuel S. Drehwald, Marcelo Domínguez, Kevin Sala, Alán Aspuru-Guzik, and Johannes Doerfert explores using LLVM's Offload infrastructure... og:url: https://daily.dev/posts/offloading-rust-to-gpus-proves-capable-of-high-performance-with-memory-safety-6ojskq9d9 og:image: https://api.daily.dev/og/posts/6ojskq9d9.png og:image:alt: Offloading Rust To GPUs Proves Capable Of High Performance With Memory Safety 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. # Offloading Rust To GPUs Proves Capable Of High Performance With Memory Safety **[Phoronix](https://daily.dev/sources/phoronix)** · 1 min read · 0 upvotes · 0 comments ## Summary A research paper from Manuel S. Drehwald, Marcelo Domínguez, Kevin Sala, Alán Aspuru-Guzik, and Johannes Doerfert explores using LLVM's Offload infrastructure to run Rust code on GPU accelerators. Benchmarks show the safe Rust front-end, which avoids raw pointers in most kernels, performs competitively against hand-optimized CUDA and HIP C++ kernels, winning some tests and losing others. The researchers note further optimization opportunities in code generation and IR differences. Upstream tracking for Rust GPU offload support continues on a Rust-lang GitHub issue. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Questions this post answers ### Can Rust code run on GPUs with performance comparable to CUDA or HIP while keeping memory safety? Yes, according to research using LLVM's Offload infrastructure to compile safe Rust code for GPU kernels. Benchmarks show performance generally competitive with native, hand-optimized CUDA and HIP C++ kernels, winning some tests and losing others, while the safe Rust front-end lets most kernels avoid raw pointers. Researchers plan further code generation improvements to close remaining performance gaps. _Developers weighing Rust against CUDA or HIP for GPU work can follow research writeups like this via daily.dev._ ### Where can I track the status of Rust support for GPU offloading? Upstream tracking for Rust's GPU offload support is maintained in a GitHub issue on the rust-lang/rust repository, issue number 131513. The underlying research paper describing the LLVM Offload implementation and its benchmark results against CUDA and HIP is available on arXiv under the identifier 2608.13759. _Anyone building toward safe GPU code in Rust can track upstream progress like this through daily.dev._ ## Similar posts on daily.dev - [I Put My Rust Code on a GPU. The Profiler Told Me to Stop.](https://daily.dev/posts/i-put-my-rust-code-on-a-gpu-the-profiler-told-me-to-stop--6e3tfkih6) · Medium · 0 upvotes · 0 comments - [Rust's standard library on the GPU](https://daily.dev/posts/rust-s-standard-library-on-the-gpu-cl7ltqdzx) · Hacker News · 1 upvotes · 0 comments - [Introducing CUDA Rust: Two Tracks for Writing GPU Kernels](https://daily.dev/posts/introducing-cuda-rust-two-tracks-for-writing-gpu-kernels-a7096aegg) · NVIDIA Developer · 49 upvotes · 4 comments --- Tags: [#general-programming](https://daily.dev/tags/general-programming), [#rust](https://daily.dev/tags/rust), [#gpu](https://daily.dev/tags/gpu), [#cuda](https://daily.dev/tags/cuda) [View this post on daily.dev](https://daily.dev/posts/offloading-rust-to-gpus-proves-capable-of-high-performance-with-memory-safety-6ojskq9d9) ```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":"Offloading Rust To GPUs Proves Capable Of High Performance With Memory Safety","url":"https://daily.dev/posts/offloading-rust-to-gpus-proves-capable-of-high-performance-with-memory-safety-6ojskq9d9","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/offloading-rust-to-gpus-proves-capable-of-high-performance-with-memory-safety-6ojskq9d9"},"datePublished":"2026-08-17T19:50:23.777Z","dateModified":"2026-09-14T06:55:44.389Z","description":"A research paper from Manuel S. Drehwald, Marcelo Domínguez, Kevin Sala, Alán Aspuru-Guzik, and Johannes Doerfert explores using LLVM's Offload infrastructure...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/4dc72ba588fba6b73e303db0f8d312bd?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/4dc72ba588fba6b73e303db0f8d312bd?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"Phoronix","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":"Phoronix","logo":"https://media.daily.dev/image/upload/t_logo,f_auto/v1/logos/6a26ba379dd64932830aa0c9803dd7ee","url":"https://daily.dev/sources/phoronix"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/offloading-rust-to-gpus-proves-capable-of-high-performance-with-memory-safety-6ojskq9d9","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":0},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"general-programming,rust,gpu,cuda","timeRequired":"PT1M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Phoronix","item":"https://daily.dev/sources/phoronix"},{"@type":"ListItem","position":3,"name":"Offloading Rust To GPUs Proves Capable Of High Performance With Memory Safety"}]} {"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/offloading-rust-to-gpus-proves-capable-of-high-performance-with-memory-safety-6ojskq9d9#faq","mainEntity":[{"@type":"Question","name":"Can Rust code run on GPUs with performance comparable to CUDA or HIP while keeping memory safety?","acceptedAnswer":{"@type":"Answer","text":"Yes, according to research using LLVM's Offload infrastructure to compile safe Rust code for GPU kernels. Benchmarks show performance generally competitive with native, hand-optimized CUDA and HIP C++ kernels, winning some tests and losing others, while the safe Rust front-end lets most kernels avoid raw pointers. Researchers plan further code generation improvements to close remaining performance gaps. Developers weighing Rust against CUDA or HIP for GPU work can follow research writeups like this via daily.dev."}},{"@type":"Question","name":"Where can I track the status of Rust support for GPU offloading?","acceptedAnswer":{"@type":"Answer","text":"Upstream tracking for Rust's GPU offload support is maintained in a GitHub issue on the rust-lang/rust repository, issue number 131513. The underlying research paper describing the LLVM Offload implementation and its benchmark results against CUDA and HIP is available on arXiv under the identifier 2608.13759. Anyone building toward safe GPU code in Rust can track upstream progress like this through daily.dev."}}]} ```