Engineering Architect, Compilers

Why this role exists

Silicon companies have compiler teams. What they don’t have is the freedom to break things, try radical approaches, or chase optimisations that take six months of exploration before they pay off. Their teams maintain releases, fix regressions, and keep the lights on. The ambitious work — the work that changes what the hardware is capable of — gets deferred.

That’s where we come in. VRULL takes on the problems that internal teams can’t prioritise: the cross-cutting optimisation that touches cost models, vectorisation, and scheduling simultaneously; the code generation for ISA extensions that don’t exist yet; the MLIR pipeline that connects a high-level graph to machine code that actually exploits the hardware. The pass that makes a 30% performance difference on an AI inference kernel or an HPC stencil computation — but requires rewriting assumptions that have been baked into the compiler for a decade.

The workloads we care about span AI and HPC: matrix operations, inference pipelines, scientific computing, large-scale simulation. The languages span just as wide — we maintain and improve Fortran compilation for the HPC codes that still drive supercomputer procurement, and we’re building toward Julia as the language that bridges scientific computing and AI with a compilation model designed for it.

AI-enabled workflows give you the throughput to attempt things that used to be too expensive to try. You decide what’s worth building. AI compresses the iteration cycle. You evaluate every result with the architectural depth that comes from knowing GCC, LLVM, and MLIR — not as a user, but as someone who shapes them.

What you’ll do

• Design and implement optimisation passes across GCC, LLVM, and MLIR — cost models, vectorisation strategies, scheduling heuristics — for AArch64 and RISC‑V
• Build code generation for RISC‑V AI and HPC extensions that are still being defined — matrix-computing instructions, inference primitives, custom ISA features for scientific workloads
• Take on the cross-compiler, cross-architecture problems that silicon teams defer: the optimisations that require understanding both the hardware pipeline and the compiler’s IR at the same time
• Work across language frontends — from Fortran optimisation for HPC workloads to exploring Julia’s compilation model and its potential on RISC‑V
• Use AI to explore design spaces that would have been prohibitively expensive — dozens of scheduling alternatives, hundreds of test variants, rapid prototyping of radical approaches
• Upstream production-quality patches into GCC, LLVM, and MLIR and maintain the community standing that gets them accepted

What we’re looking for

• Deep, hands-on experience in GCC and/or LLVM — backend development, not just usage
• The ability to work across compilers and understand their trade-offs, including MLIR’s role in the modern compilation stack
• Architectural judgement: you read compiler output and know whether it’s right before the tests tell you
• Experience with AArch64 or RISC‑V (ideally both) at the ISA level
• Interest in the full language spectrum — C/C++ and Fortran are the present; Julia and domain-specific languages are where the field is heading
• Active presence in open-source compiler communities — upstream contributions, reviewer relationships, conference engagement
• Comfort working AI-enabled: the tools generate, you evaluate and steer

What sets you apart

• Upstream commit history in both GCC and LLVM, or significant MLIR contributions
• Experience with RISC‑V vector extensions (RVV) or ARM SVE/SME on AI or HPC workloads
• Fortran optimisation experience — you know what Fortran codes actually need from a compiler, not just what the spec says
• Exposure to Julia’s compiler internals or type-specialisation model
• A track record of shipping optimisations that internal teams couldn’t or wouldn’t attempt
• The instinct to question the compiler’s assumptions, not just work within them

We’re not looking for someone who maintains a compiler. We’re looking for someone who changes what a compiler can do — across every workload and every language that matters.