Quadrants: Compiler Lead

United States Digital Space LLC; Paris (TX); On-site; USD 120,000 - 180,000; Full time

Job summary

United States Digital Space LLC is building Quadrants, an open-source Python compiler for physics simulation. You will own the API and authoring experience, ensuring the surface is natural to Python users and easy for engineers to prototype and run experiments.

The role covers IR, lowering, and backends, with a stable yet extensible IR and support for differentiable simulation. You’ll drive performance improvements while preserving usability and clarity for users.

Job description

The role

You own Quadrants end to end: the API, the IR and lowering, the optimization passes, the numerical primitives, and the roadmap.

Our ultimate objective: engineers 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 (static shapes and fixed‑size allocation baked into kernels, say), 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.

Your mandate is to build the best open‑source Python compiler for physics simulation out there. No limit on what that takes. If it means replacing the entire engine, your call. Either way, you keep Quadrants healthy and unblocking the company in the meantime.

What you’ll own

API & authoring experience. The surface that physics and numerical‑computing engineers write against, and, as an open‑source library, the product’s face to the world. Idiomatic, natural to Python users, never a separate language bolted onto Python. Clean decorators, legible constraints, sharp errors, real escape hatches.

• IR, lowering & backends. A stable IR that lowers to multiple backends, with room to grow and the door kept open for differentiable simulation. Today the computation graph is expressed through Quadrants’ own constructs. Recovering it automatically from ordinary Python is hard, and a long‑term goal rather than today’s reality.

• Optimization. Turn naive code into strong execution plans: vectorization, register and shared‑memory usage, barriers and atomics, cooperative threading, dead‑buffer and redundant‑traffic elimination, dropping needless synchronization. Move low‑level optimization off users and into the platform.

• Primitives. Cholesky, eigendecomposition, matmul, reductions, solver kernels. Each owned with its correctness, benchmarks, and regression tracking.

• Watching the company and the compiler together. Hunt for performance wins on both sides, in the company and in Quadrants itself. Propose API changes that cut duplication, improve readability, and reduce platform‑specific special‑casing. Less to maintain, more that simply works.

• The project as a product. Benchmark real workloads, track performance over time, catch regressions early. Stay close to users (the company first), find friction and missing abstractions, drive adoption, set direction.

Who you are

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

The ground that judgment stands on:

• GPU. What optimal looks like and why: access patterns, registers, shared memory, barriers, atomics, threading. CPU intuition a plus.

• Python & API taste. Idiomatic Python. A feel for what’s natural to Python users. APIs that free users rather than constrain them.

• Compilers. The path from authoring to kernels (IR, lowering, optimization), weighed against maintainability.

And how you work

Proactive and largely self‑directed. You fetch context across the company instead of waiting for it. You’re comfortable talking to the engineers who use what you build, and at ease designing in the open for users you’ll never meet. Ready to grow into leading a small team (a couple of people, near term).

What great looks like

People adopt Quadrants from outside the company. 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: blind spots shrink, the parts you can vouch for expand, technical debt goes down, the core stays sound.

That takes treating understanding as real work, not overhead. You read and challenge the codebase instead of just stacking features on it. You take nothing you did not write for granted. You watch the competition and what’s coming next, and you bring it in and ship it.

Use AI agents if they help. They are productivity tools, not code owners. You are.