Senior Compiler Engineer

Nvidia

Confirmed live today High trust

Remote

Quick summary

Work type: Remote
Location: Santa Clara, CAAustin, TXSeattle, WA
Salary: $152,000–$241,500 / yr
Employment: Full-time
Posted: 32 days ago
Freshness: Confirmed live today
Nearby: 99+ roles within 25 mi

Market check

Salary context

Above market

How this pay compares to similar roles

Similar $173k

This role $197k

$110k most similar roles pay here $256k

This role pays more than 77% of similar roles. Most pay $149,500–$196,750 — the shaded band above. At the midpoint, this role pays about $197k versus about $173k for comparable roles.

Based on 240 similar postings.

Employer

About Nvidia

Nvidia is a leading designer of graphics processing units (GPUs) and system-on-chip units, powering gaming, professional visualization, data centers, and artificial intelligence workloads. Industry: Semiconductors & AI Computing

Nvidia currently has 1391 open roles on FindRole.

Listed pay typically runs $184,000–$287,500 across 1116 roles with salary data.

Most-posted roles

View all roles at Nvidia

At a glance

TL;DR · Senior Compiler Engineer

Role Posting Log in to save

The Senior Compiler Engineer joins the team driving next-generation GPU systems programming to redefine how developers write high-performance GPU software. This role focuses on bringing Rust’s safety and expressiveness to native GPU and CUDA development. You will build cutting-edge compiler pipelines, custom intermediate representation frameworks, and JIT compilation systems that bridge host and device execution. Key responsibilities include developing Rust-to-GPU compiler pipelines, implementing backend codegen for PTX and machine code, and designing compiler-enforced safety models to prevent data races during asynchronous GPU execution. You will work with technologies including Rust, rustc, MLIR, LLVM IR, and CUDA. The role involves exposing hardware features like Tensor Memory Accelerator and warp/cluster operations through type-safe abstractions. You must possess expertise in compiler internals, procedural macros, and parallel programming models to solve complex problems in GPU code generation and optimization.

Skills

Rust CUDA LLVM MLIR PTX rustc JIT Intermediate Representation (IR) Parallel Programming GPU Architecture Cargo Profiling Benchmarking Domain-Specific Languages (DSLs)

What you'll do

Design and maintain custom compiler backends and proc-macros to compile Rust directly to CUDA PTX and machine code.
Develop intermediate representation (IR) frameworks using MLIR, LLVM, and other architectures to lower Rust AST and MIR.
Implement GPU-specific optimizations and support advanced ahead-of-time, just-in-time, and link-time optimization workflows.
Architect compiler-enforced safety models that extend Rust's ownership and borrowing rules across the GPU launch boundary.
Create type-safe, ergonomic Rust abstractions for low-level hardware primitives like shared memory, barriers, and Tensor Memory Accelerator.
Build state-of-the-art tooling to support a broad range of NVIDIA GPUs and host platforms.
Drive complex compiler engineering projects from initial research through to production-ready code.

What we're looking for

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 rustc internals, MIR, procedural macros, and the borrow-checker/lifetime model.
Hands-on experience with compiler infrastructures, intermediate representations (IRs), and code generation such as LLVM IR or MLIR.
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 work independently to define project goals and drive complex compiler-engineering efforts from research to production.
Experience with custom front-ends, JIT engines, or designing DSLs for tensor processing (preferred).