Backend Compiler Engineer

Acceler8; United States; On-site; USD 140,000 - 220,000; Full time

Job summary

Acceler8 Talent is seeking a Compiler Engineer to build hardware-close compiler backends for a specialized AI accelerator. You will translate model graphs into executable code, reason about IR transformations and lowerings, and ensure performance on custom hardware.

This role collaborates across architecture, runtime, and model teams in a production environment. The ideal candidate brings deep compiler fundamentals, C++ expertise, and hands-on ownership of compiler components, with experience in

Qualifications

• Proven ownership of compiler backends and IR transformation passes.
• Strong fundamentals in compilers, graph reasoning and C++ software engineering.
• Ability to explain how compiler decisions affect memory use, scheduling and device performance.
• Experience delivering substantial compiler components and debugging complex technical issues.
• Understanding of compiler IR representations, transformation legality, dependencies and graph-to-execution mapping.
• Ability to make backend design decisions independently with clear reasoning.
• Experience using tests, debugging and workload results to validate compiler changes beyond API integration.

Responsibilities

• Design and deliver compiler backend components, including IR transformations, lowering and code generation.
• Map graph and model computation onto the execution capabilities and constraints of specialized hardware.
• Reason about memory behavior, scheduling and data movement when making compiler design decisions.
• Debug correctness and performance issues across compiler, runtime and hardware interfaces.
• Evaluate changes through real workloads and device execution, connecting implementation choices to measured results.
• Collaborate across the accelerator stack as the architecture and software platform evolve.
• Design IR representations and transformation logic that preserve program meaning while exposing hardware constraints.
• Implement lowering and code-generation paths, mapping computations and dependencies to the target execution model.
• Investigate how compiler choices affect intermediate storage, data movement and scheduling with architecture/runtime teams.
• Build focused tests and workload-level checks to detect miscompilations and regressions.
• Trace problems from model/graph inputs through compiler to runtime and device behavior.

Skills

Compiler backends

IR transformations

Code generation

Graph reasoning

C++ software engineering

Memory behavior understanding

Scheduling and data movement

Independent delivery of compiler parts

Debugging complex problems

Backend design decisions

Testing and workload validation

Tools

LLVM

MLIR

Job description

Compiler Engineer

Backend and hardware targeting | Specialized AI accelerators

The opportunity

Acceler8 Talent is partnering with an AI hardware startup developing a specialized accelerator and its software stack. The team is hiring a Compiler Engineer to build the hardware-close components that turn model computation into correct, efficient execution on a custom processor.

This role centers on compiler fundamentals, intermediate representations, lowering and code generation. You will connect graph and compiler decisions to actual device behavior, working closely with architecture, kernel, runtime and model teams.

Technical scope

The compiler connects model computation with the capabilities and limitations of a specialized processor. You will reason about intermediate representations, transformation legality and how computation is lowered into an executable form. Memory behavior, scheduling and data movement are central to the design, so the role requires understanding why a compiler decision changes actual execution rather than stopping at a successful compilation.

What you will do

• Design and deliver compiler backend components, including IR transformations, lowering and code generation.
• Map graph and model computation onto the execution capabilities and constraints of specialized hardware.
• Reason about memory behavior, scheduling and data movement when making compiler design decisions.
• Debug correctness and performance issues across compiler, runtime and hardware interfaces.
• Evaluate changes through real workloads and device execution, connecting implementation choices to measured results.
• Collaborate across the accelerator stack as the architecture and software platform evolve.
• Design IR representations and transformation logic that preserve program meaning while making hardware constraints explicit.
• Implement lowering and code-generation paths, defining how computation and dependencies map onto the target execution model.
• Investigate how compiler choices affect intermediate storage, data movement and scheduling, working with architecture and runtime engineers on trade-offs.
• Build focused tests and workload-level checks to detect miscompilations, isolate regressions and validate new compiler behavior.
• Trace problems from model or graph input through compiler transformations to runtime and device behavior, distinguishing correctness issues from performance limitations.

What you will bring

• Production ownership of compiler backends, lowering, IR, transformation passes or code generation.
• Strong compiler fundamentals, graph reasoning and C++ software engineering.
• Ability to explain how your compiler decisions affect memory use, scheduling, correctness and device performance.
• Experience independently delivering substantial compiler components and debugging complex technical problems.
• Understanding of compiler intermediate representations, transformation legality, dependencies and the relationship between graph structure and execution.
• Ability to make and implement backend design decisions independently, with clear reasoning about alternatives and target constraints.
• Experience using tests, debugging and workload results to validate compiler changes beyond API integration or routine maintenance.

Useful experience

• Compiler work targeting accelerators, GPUs, NPUs, DSPs or other specialized processors.
• LLVM or MLIR experience involving substantive compiler design and implementation ownership.
• Debugging compiler behavior against runtime or real device execution, including memory, scheduling and performance analysis.
• Around five years of relevant experience can be a strong fit when supported by deep production ownership and independent technical judgment.