Senior Compiler Engineer – Rust GPU

NVIDIA; Santa Clara (CA); On-site; USD 152,000 - 241,500; Full time

Benefits offered by this job

Equity

Benefits

Job summary

NVIDIA in Santa Clara, CA is seeking a senior compiler engineer to design and implement Rust-to-GPU compiler pipelines, turning Rust into CUDA PTX and machine code. You will build IRs, backends, and optimizers, and work with MLIR, PTX, and LLVM to optimize GPU workloads.

You will advance safe parallel abstractions across the GPU boundary, expose device-side primitives, and contribute to reusable building blocks for future accelerators.

Qualifications

• Bachelor's, Master's, or Ph.D. in CS, CE, or related field.
• 5+ years of compiler development, language design, or GPU code generation.
• Deep expertise in Rust, including rustc, MIR, procedural macros, and borrow-checker.
• Hands-on experience with IRs and code generation (LLVM IR, MLIR, or custom IR).
• Solid understanding of parallel programming models and CUDA.

Responsibilities

• Develop Rust-to-GPU compiler pipelines: design, implement, and maintain custom compiler backends and Rust-native IR frameworks to compile standard Rust to CUDA PTX and machine code.
• Build compiler IRs and optimizers for GPU targets (MLIR, PTX, LLVM).
• Support ahead-of-time, JIT, and link-time optimization workflows for NVIDIA GPUs and host platforms.
• Define safe parallel abstractions across GPU launch boundaries to prevent data races and ensure memory safety.
• Expose device-side abstractions for shared memory, barriers, atomics, and Tensor Memory Accelerator (TMA).
• Build the future by creating composable building blocks for others to develop tomorrow’s applications.

Skills

Rust expertise

Compiler internals

GPU code generation

Rust MIR

Procedural macros

CUDA/CUDA PTX

Parallel programming

Debugging & profiling

Education

Bachelor's/Master's/PhD in CS or related

Equivalent experience

Tools

LLVM IR

MLIR

Custom IR systems

Job description

What you’ll be doing:

• Develop Rust-to-GPU Compiler Pipelines: Design, implement, and maintain custom compiler backends (such as rustc codegen backends and proc-macros) and Rust-native intermediate representation (IR) frameworks to compile standard Rust directly to high-performance CUDA PTX and machine code.

• Build compiler IRs and Optimizers: Work with modern compiler architectures to lower Rust AST and MIR into IRs including MLIR, PTX, and LLVM, including GPU-specific optimizations.

• Support complex ahead-of-time, just-in-time, and link time optimization workflows: Build state-of-the‑art tooling to support users targeting a broad family of NVIDIA GPUs, host platforms, and feature sets.

• Define Safe Parallel Abstractions: Architect innovative compiler‑enforced safety models that extend Rust's ownership, borrowing, and lifetime disciplines across the GPU launch boundary—preventing data races and enforcing memory safety during asynchronous GPU execution.

• Expose Next‑Gen Hardware Features: Implement type‑safe, ergonomic device‑side abstractions in Rust for low‑level GPU hardware primitives, including shared memory, barriers, scoped atomics, Tensor Memory Accelerator (TMA), and warp/cluster‑level operations.

• Build the future: Supporting today’s accelerated computing applications is not sufficient. We have to build composable building blocks for others around us to build the applications of tomorrow.

What we need to see:

• Bachelor's, Master's, or Ph.D. in Computer Science, Computer Engineering, a related field, or equivalent experience.

• 5+ years of relevant work or research experience in compiler development, language design, or GPU code generation.

• Deep expertise in the Rust programming language, including a strong grasp of compiler internals (rustc), Rust MIR, procedural macros, and Rust's borrow-checker/lifetime model.

• Hands‑on experience with compiler infrastructures, intermediate representations (IRs), and code generation (such as LLVM IR, MLIR, or custom IR systems).

• Solid understanding of parallel programming models, GPU architectures, and CUDA programming.

• Strong software design skills, including debugging, profiling, and benchmarking compilers and GPU kernels.

• Ability to orchestrate agents for product requirement design, architecture, code development, testing, code review, and issue triage.

• Ability to work independently, define project goals and scope, and drive complex compiler‑engineering efforts from research to production.

Ways to stand out from the crowd:

• A track record of contributing to the Rust compiler (rustc), Cargo tooling, or open‑source Rust‑to‑GPU projects.

• Experience building custom compiler front‑ends, AST translators, or JIT engines.

• Familiarity with MLIR or other extensible compiler frameworks.

• Deep proficiency in low‑level GPU programming, including the use of modern hardware features (e.g., Tensor Cores, warp‑level shuffles, or asynchronous transfer pipelines).

• Experience designing Domain‑Specific Languages (DSLs) or tile‑based programming abstractions for tensor processing.

Your base salary will be determined based on your location, experience, and the pay of employees in similar positions. The base salary range is 152,000 USD - 241,500 USD.

You will also be eligible for equity and benefits.

NVIDIA is committed to fostering an inclusive work environment and proud to be an equal opportunity employer. As we highly value diversity in our current and future employees, we do not discriminate (including in our hiring and promotion practices) on the basis of race, religion, color, national origin, gender, gender expression, sexual orientation, age, marital status, veteran status, disability status or any other characteristic protected by law.