ML Compiler & System in London

Quadrants is an open-source translation layer that turns ordinary Python into optimized machine code at runtime, across CPU (Arm64, x86) and GPU (AMDGPU, CUDA, Metal, Vulkan) backends. The ambition is explicit: build the best “Python compiler” in the world for physics and performance-critical numerical computing. We are fully committed to it, and we intend to beat leading alternatives like Nvidia Warp, Numba, or Triton.

It’s a standalone project with its own roadmap, built in the open. Genesis, our physics simulator, is its first and top-priority user, the source of its hardest workloads and its benchmarks. But Quadrants is general-purpose infrastructure for anyone writing performance-critical numerical Python, not an internal tool that happens to be public.

The role involves owning Quadrants end to end: the API, the IR and lowering, the optimization passes, the numerical primitives, and the roadmap. Our ultimate objective is for engineers to write for readability and maintainability, never for performance. They write the version of an algorithm they are most comfortable with, and Quadrants rebuilds it into kernels that run as if an expert had hand-tuned them. Performance is the compiler’s job, not theirs.

Getting there is a frontier problem, part research and part engineering, and we intend to define the state of the art on it, relentlessly pushing the limit further. It calls for two things at once: the low-level GPU and compiler skill to make a single kernel optimal, and the ability to keep the whole system coherent as it grows.

The core tradeoff is settled: usability comes first. When usability and performance collide, usability wins, unless the cost is severe. We will limit what the system supports to go fast but never the convenience of the API itself. Experts who want maximum performance and full control over the generated code get lower-level escape hatches, down to inline assembly, C, or PTX.

What you’ll own:

• API & authoring experience: The surface that physics and numerical-computing engineers write against, idiomatic and natural to Python users.
• IR, lowering & backends: A stable IR that lowers to multiple backends, with room to grow.
• Optimization: Turn naive code into strong execution plans.
• Primitives: Cholesky, eigendecomposition, matmul, reductions, solver kernels.
• Watching Genesis and the compiler together: Hunt for performance wins on both sides.
• The project as a product: Benchmark real workloads, track performance over time.

Who you are:

• You reason about whole systems and have taste for where complexity should live.
• You measure before you optimize, reaching for memory traffic and launch overhead before FLOPs.
• You have opinions about API design and write tests and benchmarks as you go.

What great looks like:

• People adopt Quadrants from outside Genesis.
• Engineers write clearer code with less boilerplate.
• Kernels keep getting faster.
• Performance is tracked, not guessed.
• The architecture gets easier to extend, not harder.

What we’re uncompromising about:

• How you work is up to you. What matters is that your ownership grows over time.
• You treat understanding as real work, not overhead.
• You watch the competition and what’s coming next, and you bring it in and ship it.