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

Originally posted 13 August 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.
• Develop or improve bare-metal and `no_std` Rust components where explicit state, bounded behavior, fail-closed handling, and predictable hardware effects are required.
• 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.

What you'll need

• Experience working across abstraction layers, including Rust source semantics, rustc internals, intermediate representations, MLIR and LLVM, target-specific code generation, object formats, runtimes, GPU ISA, firmware, and hardware interfaces.
• Experience with testing, fuzzing, property-based testing, differential execution, executable models, and hardware validation to find semantic gaps and prevent regressions.
• Ability to distinguish precisely among type-system guarantees, source-level proofs, compiler evidence, binary validation, simulator results, and behavior observed on hardware.
• Partnership with compiler, runtime, firmware, architecture, validation, security, and performance teams.
• Ability to write design documents, lead technical reviews, mentor engineers, and explain complex language, compiler, and hardware behavior clearly.
• Ability to evaluate emerging compiler and verification technologies and integrate them when they improve safety, performance, maintainability, or development velocity of production systems.

Nice to have

• Strong production Rust experience, including ownership and borrowing, lifetimes, traits and generics, error handling, concurrency, FFI, and 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, and 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