{"schemaVersion":"jobsearcher.job.v1","id":"f48a25947a68fb94614a61da","url":"https://jobsearcher.com/jobs/f48a25947a68fb94614a61da","canonicalUrl":"https://jobsearcher.com/jobs/f48a25947a68fb94614a61da","title":"Staff Software Development Engineer - Rust, Compilers, and GPU Systems","description":"Overview:\nADVANCE YOUR CAREER. ADVANCE THE WORLD.\nAt AMD, we believe technology can change lives for the better. It can heal us, entertain us, and make us more connected, productive, and understanding of the world around us. And we’re looking for talent who feel the same: people who want to leave the planet better than they found it, those who don’t shy away from humanity’s challenges but are determined to help solve them.\n\nAMD is powering the next generation of supercomputing, high-performance computing, cloud, and AI. Whether you’re designing next-gen processors, enabling AI breakthroughs, or creating go-to-market plans, every role at AMD contributes to something bigger — technology that moves the world forward.\nResponsibilities:\nThe Role\nWe are building next-generation systems software for AMD GPUs with Rust as a core technical direction. 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.\nRust is not incidental to this role. You will help establish how Rust is used in performance-sensitive and high-trust parts of the GPU stack, including the compiler and tooling support, system interfaces, engineering practices, and validation methods required for production deployment. You will have the opportunity to influence both near-term implementations and the longer-term architecture for using Rust across current and future AMD platforms.\n\nThe Person\nThis role is for a deeply technical compiler and systems generalist who enjoys working across abstraction layers. You may move between Rust source semantics, rustc internals, intermediate representations, MLIR and LLVM, target-specific code generation, object formats, runtimes, GPU ISA, firmware, and hardware interfaces.\nYou should have strong judgment about correctness boundaries. Memory safety is important, but production correctness also depends on concurrency, ordering, ABI compatibility, device behavior, compiler transformations, and the assumptions between software and hardware. You will help make those assumptions explicit and build evidence that the resulting systems behave as intended.\nThe ideal candidate has deep expertise in at least one part of this stack and the ability to become productive in unfamiliar areas. Experience with every technology listed below is not expected. A research background is not required, although the ability to read technical work, form testable hypotheses, and turn promising ideas into reliable implementations is valuable.\nThe work sits at the intersection of Rust systems programming, production compiler infrastructure, GPU architecture, firmware, program analysis, and formal methods. Hardware-software co-design experience is highly valuable, especially when compiler, runtime, firmware, or ISA choices must evolve together.\n\nKey Responsibilities\nLead the design and implementation of production-quality Rust components for low-level and performance-sensitive GPU systems.\nHelp make Rust a first-class engineering language across relevant parts of the GPU software stack, including toolchain integration, libraries, coding standards, diagnostics, testing, and deployment practices.\nDesign and implement compiler pipelines involving rustc, MIR, target-neutral intermediate representations, MLIR dialects and transformations, LLVM IR, and AMDGPU code generation.\nBuild analyses, transformations, legalization passes, and target-specific lowering for GPU execution models, memory spaces, synchronization, capabilities, and specialized hardware operations.\nDefine typed and auditable interfaces across compiler, host runtime, device code, firmware, and hardware boundaries.\nWork on ABI definition and validation, argument layout, calling conventions, linker and loader behavior, ELF and code-object metadata, and source-to-binary identity.\nDevelop or improve bare-metal and no std Rust components where explicit state, bounded behavior, fail-closed handling, and predictable hardware effects are required.\nUse testing, fuzzing, property-based testing, differential execution, executable models, and hardware validation to find semantic gaps and prevent regressions.\nApply program analysis or formal methods where they provide meaningful assurance, including source-level invariants, state-machine properties, refinement obligations, and clearly documented trusted boundaries.\nDistinguish precisely among type-system guarantees, source-level proofs, compiler evidence, binary validation, simulator results, and behavior observed on hardware.\nPartner with compiler, runtime, firmware, architecture, validation, security, and performance teams to solve problems that cross organizational and technical boundaries.\nWrite design documents, lead technical reviews, mentor engineers, and explain complex language, compiler, and hardware behavior clearly.\nEvaluate emerging compiler and verification technologies and integrate them when they improve the safety, performance, maintainability, or development velocity of production systems.\nPreferred Experience\nStrong 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.\nExperience with low-level or constrained Rust, including no std, embedded systems, firmware, custom targets, allocators, volatile access, interrupt handling, or architecture-specific code.\nStrong C or C++ systems programming skills and the ability to work across mixed-language codebases.\nExperience with rustc internals, MIR, custom codegen backends, procedural macros, compiler plugins, or other Rust toolchain infrastructure.\nExperience with LLVM, MLIR, GCC, or another production compiler framework.\nExperience designing intermediate representations, dialects, analyses, optimization passes, legalization, instruction selection, scheduling, or target-specific code generation.\nUnderstanding of compiler correctness issues such as undefined behavior, aliasing, provenance, layout, calling conventions, memory models, and source-to-target semantic preservation.\nAbility to read and reason about low-level assembly, ISA encodings, compiler output, and machine-level execution.\nExperience with linkers, loaders, ELF or other object formats, code-object metadata, DWARF, LLVM MC, disassembly, post-link analysis, or binary rewriting.\nUnderstanding 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.\nAMDGPU, GCN, RDNA, CDNA, ROCm, HIP, HSA, or AMDGPU LLVM backend experience.\nExperience with GPU runtimes, drivers, firmware, embedded processors, device initialization, command processing, queueing, or hardware control paths.\nExperience building secure or high-assurance systems that process untrusted inputs or operate across privilege, memory-isolation, or hardware trust boundaries.\nExperience with program analysis, abstract interpretation, symbolic execution, model checking, SMT solvers, or formal verification tools such as Verus, Lean, Coq, Isabelle, Dafny, or TLA+.\nExperience writing executable specifications, proving state-machine invariants, or validating refinement between source, IR, binaries, simulators, RTL, and hardware.\nStrong validation instincts, including adversarial testing, differential testing, property-based testing, fuzzing, reproducible evidence, and careful treatment of assumptions and counterexamples.\nHardware-software co-design experience for ISA features, compiler-visible architecture, memory systems, synchronization, security mechanisms, or specialized compute pipelines.\nTechnical leadership experience: setting direction, resolving ambiguous cross-layer problems, influencing partner teams, mentoring engineers, and communicating tradeoffs clearly.\nPreferred Academic Credentials\nBachelor's, Master's, or PhD in Computer Science, Computer Engineering, Electrical Engineering, or a related field, or equivalent industry experience. Research publications and advanced degrees are welcome but are not required.\n\n#LI-G11\n\n#LI-HYBRID\n\nThis role is not eligible for visa sponsorship.\nQualifications:\nBenefits offered are described: AMD benefits at a glance.\n\nAMD does not accept unsolicited resumes from headhunters, recruitment agencies, or fee-based recruitment services. AMD and its subsidiaries are equal opportunity, inclusive employers and will consider all applicants without regard to age, ancestry, color, marital status, medical condition, mental or physical disability, national origin, race, religion, political and/or third-party affiliation, sex, pregnancy, sexual orientation, gender identity, military or veteran status, or any other characteristic protected by law. We encourage applications from all qualified candidates and will accommodate applicants’ needs under the respective laws throughout all stages of the recruitment and selection process.\n\nAMD may use Artificial Intelligence to help screen, assess or select applicants for this position. AMD’s “Responsible AI Policy” is available here.\n\nThis posting is for an existing vacancy.","company":"Advanced Micro Devices","rawCompany":"advanced micro devices","city":"San Jose","state":"CA","isRemote":false,"isActive":false,"createdAt":"2026-08-11T01:32:17.150Z","occupations":[{"code":"15-1252.00","title":"Software Developers","slug":"software-developers"},{"code":"15-1299.08","title":"Computer Systems Engineers/Architects","slug":"computer-systems-engineers-architects"},{"code":"15-1251.00","title":"Computer Programmers","slug":"computer-programmers"}],"industries":[{"code":"513210","title":"Software Publishers","slug":"software-publishers"},{"code":"541512","title":"Computer Systems Design Services","slug":"computer-systems-design-services"},{"code":"334111","title":"Electronic Computer Manufacturing","slug":"electronic-computer-manufacturing"}],"jobPosting":{"@context":"https://schema.org","@type":"JobPosting","title":"Staff Software Development Engineer - Rust, Compilers, and GPU Systems","description":"Overview:\nADVANCE YOUR CAREER. ADVANCE THE WORLD.\nAt AMD, we believe technology can change lives for the better. It can heal us, entertain us, and make us more connected, productive, and understanding of the world around us. And we’re looking for talent who feel the same: people who want to leave the planet better than they found it, those who don’t shy away from humanity’s challenges but are determined to help solve them.\n\nAMD is powering the next generation of supercomputing, high-performance computing, cloud, and AI. Whether you’re designing next-gen processors, enabling AI breakthroughs, or creating go-to-market plans, every role at AMD contributes to something bigger — technology that moves the world forward.\nResponsibilities:\nThe Role\nWe are building next-generation systems software for AMD GPUs with Rust as a core technical direction. 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.\nRust is not incidental to this role. You will help establish how Rust is used in performance-sensitive and high-trust parts of the GPU stack, including the compiler and tooling support, system interfaces, engineering practices, and validation methods required for production deployment. You will have the opportunity to influence both near-term implementations and the longer-term architecture for using Rust across current and future AMD platforms.\n\nThe Person\nThis role is for a deeply technical compiler and systems generalist who enjoys working across abstraction layers. You may move between Rust source semantics, rustc internals, intermediate representations, MLIR and LLVM, target-specific code generation, object formats, runtimes, GPU ISA, firmware, and hardware interfaces.\nYou should have strong judgment about correctness boundaries. Memory safety is important, but production correctness also depends on concurrency, ordering, ABI compatibility, device behavior, compiler transformations, and the assumptions between software and hardware. You will help make those assumptions explicit and build evidence that the resulting systems behave as intended.\nThe ideal candidate has deep expertise in at least one part of this stack and the ability to become productive in unfamiliar areas. Experience with every technology listed below is not expected. A research background is not required, although the ability to read technical work, form testable hypotheses, and turn promising ideas into reliable implementations is valuable.\nThe work sits at the intersection of Rust systems programming, production compiler infrastructure, GPU architecture, firmware, program analysis, and formal methods. Hardware-software co-design experience is highly valuable, especially when compiler, runtime, firmware, or ISA choices must evolve together.\n\nKey Responsibilities\nLead the design and implementation of production-quality Rust components for low-level and performance-sensitive GPU systems.\nHelp make Rust a first-class engineering language across relevant parts of the GPU software stack, including toolchain integration, libraries, coding standards, diagnostics, testing, and deployment practices.\nDesign and implement compiler pipelines involving rustc, MIR, target-neutral intermediate representations, MLIR dialects and transformations, LLVM IR, and AMDGPU code generation.\nBuild analyses, transformations, legalization passes, and target-specific lowering for GPU execution models, memory spaces, synchronization, capabilities, and specialized hardware operations.\nDefine typed and auditable interfaces across compiler, host runtime, device code, firmware, and hardware boundaries.\nWork on ABI definition and validation, argument layout, calling conventions, linker and loader behavior, ELF and code-object metadata, and source-to-binary identity.\nDevelop or improve bare-metal and no std Rust components where explicit state, bounded behavior, fail-closed handling, and predictable hardware effects are required.\nUse testing, fuzzing, property-based testing, differential execution, executable models, and hardware validation to find semantic gaps and prevent regressions.\nApply program analysis or formal methods where they provide meaningful assurance, including source-level invariants, state-machine properties, refinement obligations, and clearly documented trusted boundaries.\nDistinguish precisely among type-system guarantees, source-level proofs, compiler evidence, binary validation, simulator results, and behavior observed on hardware.\nPartner with compiler, runtime, firmware, architecture, validation, security, and performance teams to solve problems that cross organizational and technical boundaries.\nWrite design documents, lead technical reviews, mentor engineers, and explain complex language, compiler, and hardware behavior clearly.\nEvaluate emerging compiler and verification technologies and integrate them when they improve the safety, performance, maintainability, or development velocity of production systems.\nPreferred Experience\nStrong 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.\nExperience with low-level or constrained Rust, including no std, embedded systems, firmware, custom targets, allocators, volatile access, interrupt handling, or architecture-specific code.\nStrong C or C++ systems programming skills and the ability to work across mixed-language codebases.\nExperience with rustc internals, MIR, custom codegen backends, procedural macros, compiler plugins, or other Rust toolchain infrastructure.\nExperience with LLVM, MLIR, GCC, or another production compiler framework.\nExperience designing intermediate representations, dialects, analyses, optimization passes, legalization, instruction selection, scheduling, or target-specific code generation.\nUnderstanding of compiler correctness issues such as undefined behavior, aliasing, provenance, layout, calling conventions, memory models, and source-to-target semantic preservation.\nAbility to read and reason about low-level assembly, ISA encodings, compiler output, and machine-level execution.\nExperience with linkers, loaders, ELF or other object formats, code-object metadata, DWARF, LLVM MC, disassembly, post-link analysis, or binary rewriting.\nUnderstanding 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.\nAMDGPU, GCN, RDNA, CDNA, ROCm, HIP, HSA, or AMDGPU LLVM backend experience.\nExperience with GPU runtimes, drivers, firmware, embedded processors, device initialization, command processing, queueing, or hardware control paths.\nExperience building secure or high-assurance systems that process untrusted inputs or operate across privilege, memory-isolation, or hardware trust boundaries.\nExperience with program analysis, abstract interpretation, symbolic execution, model checking, SMT solvers, or formal verification tools such as Verus, Lean, Coq, Isabelle, Dafny, or TLA+.\nExperience writing executable specifications, proving state-machine invariants, or validating refinement between source, IR, binaries, simulators, RTL, and hardware.\nStrong validation instincts, including adversarial testing, differential testing, property-based testing, fuzzing, reproducible evidence, and careful treatment of assumptions and counterexamples.\nHardware-software co-design experience for ISA features, compiler-visible architecture, memory systems, synchronization, security mechanisms, or specialized compute pipelines.\nTechnical leadership experience: setting direction, resolving ambiguous cross-layer problems, influencing partner teams, mentoring engineers, and communicating tradeoffs clearly.\nPreferred Academic Credentials\nBachelor's, Master's, or PhD in Computer Science, Computer Engineering, Electrical Engineering, or a related field, or equivalent industry experience. Research publications and advanced degrees are welcome but are not required.\n\n#LI-G11\n\n#LI-HYBRID\n\nThis role is not eligible for visa sponsorship.\nQualifications:\nBenefits offered are described: AMD benefits at a glance.\n\nAMD does not accept unsolicited resumes from headhunters, recruitment agencies, or fee-based recruitment services. AMD and its subsidiaries are equal opportunity, inclusive employers and will consider all applicants without regard to age, ancestry, color, marital status, medical condition, mental or physical disability, national origin, race, religion, political and/or third-party affiliation, sex, pregnancy, sexual orientation, gender identity, military or veteran status, or any other characteristic protected by law. We encourage applications from all qualified candidates and will accommodate applicants’ needs under the respective laws throughout all stages of the recruitment and selection process.\n\nAMD may use Artificial Intelligence to help screen, assess or select applicants for this position. AMD’s “Responsible AI Policy” is available here.\n\nThis posting is for an existing vacancy.","datePosted":"2026-08-11T01:32:17.150Z","dateModified":"2026-08-11T01:32:17.150Z","hiringOrganization":{"@type":"Organization","name":"Advanced Micro Devices","sameAs":"https://jobsearcher.com"},"jobLocation":{"@type":"Place","address":{"@type":"PostalAddress","addressLocality":"San Jose","addressRegion":"CA","addressCountry":"US"}},"identifier":{"@type":"PropertyValue","name":"JobSearcher","value":"f48a25947a68fb94614a61da"},"url":"https://jobsearcher.com/jobs/f48a25947a68fb94614a61da"}}