Staff Software Development Engineer - Rust, Compilers, and GPU Systems (3) - CA, San Jose, United States

Originally posted 1 September 2026 by the employer.

About the role

The work spans compilers, runtimes, low-level GPU software, firmware, developer tooling, and methods for improving the safety and correctness of complex hardware-software systems.

What you'll do

• Lead the design and implementation of production-quality Rust components for low-level and performance-sensitive GPU systems.
• Design and implement compiler pipelines involving rustc, MIR, target-neutral intermediate representations, MLIR dialects and transformations, LLVM IR, and AMDGPU code generation.
• Define typed and auditable interfaces across compiler, host runtime, device code, firmware, and hardware boundaries.
• Work on ABI definition and validation, argument layout, calling conventions, linker and loader behavior, ELF and code-object metadata, and source-to-binary identity.
• Apply program analysis or formal methods where they provide meaningful assurance, including source-level invariants, state-machine properties, refinement obligations, and clearly documented trusted boundaries.
• Partner with compiler, runtime, firmware, architecture, validation, security, and performance teams to solve problems that cross organizational and technical boundaries.

What you'll need

• Deep technical compiler and systems generalist expertise.
• Strong judgment about correctness boundaries, including memory safety, concurrency, ordering, ABI compatibility, device behavior, compiler transformations, and assumptions between software and hardware.
• Ability to read technical work, form testable hypotheses, and turn promising ideas into reliable implementations.
• Experience with Rust systems programming, production compiler infrastructure, GPU architecture, firmware, program analysis, and formal methods.
• Experience with rustc internals, intermediate representations, MLIR, LLVM, target-specific code generation, object formats, runtimes, GPU ISA, firmware, and hardware interfaces.

Nice to have

• Strong production Rust experience, including ownership and borrowing, lifetimes, traits and generics, error handling, concurrency, FFI, and the careful design of safe abstractions over unsafe operations.
• Experience with low-level or constrained Rust, including no std, embedded systems, firmware, custom targets, allocators, volatile access, interrupt handling, or architecture-specific code.
• Strong C or C++ systems programming skills and the ability to work across mixed-language codebases.
• Experience with rustc internals, MIR, custom codegen backends, procedural macros, compiler plugins, or other Rust toolchain infrastructure.
• Experience with LLVM, MLIR, GCC, or another production compiler framework.
• Experience designing intermediate representations, dialects, analyses, optimization passes, legalization, instruction selection, scheduling, or target-specific code generation.
• Understanding of compiler correctness issues such as undefined behavior, aliasing, provenance, layout, calling conventions, memory models, and source-to-target semantic preservation.
• Ability to read and reason about low-level assembly, ISA encodings, compiler output, and machine-level execution.
• Experience with linkers, loaders, ELF or other object formats, code-object metadata, DWARF, LLVM MC, disassembly, post-link analysis, or binary rewriting.
• Understanding of GPU execution models, including waves or warps, SIMD/SIMT execution, address spaces, registers, local or shared memory, caches, synchronization, atomics, barriers, and asynchronous operations.
• AMDGPU, GCN, RDNA, CDNA, ROCm, HIP, HSA, or AMDGPU LLVM backend experience.
• Experience with GPU runtimes, drivers, firmware, embedded processors, device initialization, command processing, queueing, or hardware control paths.
• Experience building secure or high-assurance systems that process untrusted inputs or operate across privilege, memory-isolation, or hardware trust boundaries.
• Experience with program analysis, abstract interpretation, symbolic execution, model checking, SMT solvers, or formal verification tools such as Verus, Lean, Coq, Isabelle, Dafny, or TLA+.
• Experience writing executable specifications, proving state-machine invariants, or validating refinement between source, IR, binaries, simulators, RTL, and hardware.
• Strong validation instincts, including adversarial testing, differential testing, property-based testing, fuzzing, reproducible evidence, and careful treatment of assumptions and counterexamples.
• Hardware-software co-design experience for ISA features, compiler-visible architecture, memory systems, synchronization, security mechanisms, or specialized compute pipelines.
• Technical leadership experience: setting direction, resolving ambiguous cross-layer problems, influencing partner teams, mentoring engineers, and communicating tradeoffs clearly.

Skills: GPU systems software, Rust, compilers, runtimes, low-level GPU software, MLIR, LLVM