Lattner, Chris

creator of LLVM, Clang, and Swift; co-founder of Modular and creator of the Mojo programming language; third appearance

Chris Lattner: Future of Programming and AI

Lex Fridman Podcast · Jun 2, 2023

• Chris Lattner
• Mojo programming language
• Modular AI infrastructure
• Python superset design
• compile-time metaprogramming and autotuning
• value semantics and ownership
• Swift and Apple lessons learned
• PyTorch and TensorFlow deployment problem
• AI hardware fragmentation
• AI concentration and accessibility

Core ideas

Lattner frames Mojo and its parent company Modular as a response to a specific, worsening crisis in AI infrastructure: on one side an explosion of AI hardware (GPUs, TPUs, NPUs, and thousands of specialized accelerators), and on the other an explosion of algorithmic complexity (modern ML frameworks now have roughly 2,000 distinct operators), with existing frameworks like TensorFlow and PyTorch — designed years before LLMs existed — straining to bridge the two. His core thesis is that computing is not going to get simpler as physics pushes hardware toward ever more specialization, so the goal of Mojo is to build a "universal platform" that lets people write code once and have it map efficiently onto whatever weird new hardware comes next, without constant rewrites. He's explicit that Mojo exists only because Modular needed it to solve this infrastructure problem — not as an end in itself — and that if Python were already sufficient, they wouldn't have built a new language at all.

Mojo's central design commitment is being a strict superset of Python (not a Python-inspired new language, and not merely Python-compatible) — deliberately keeping Python's indentation-based syntax, its dynamic object model, and its metaprogramming feel, while adding systems-programming capabilities Python lacks: static compilation alongside interpretation, optional/progressive typing (types are enforced by the compiler when used, unlike Python's type hints, which the interpreter ignores), value semantics with copy-on-write behavior to eliminate a whole class of aliasing bugs, an ownership/borrowing system inspired by Rust and Swift, and "zero-cost" error handling implemented as fast as normal returns (unlike C++ exceptions, which he calls falsely named "zero-cost" given how expensive throwing actually is). A signature technical feature is compile-time metaprogramming: Mojo takes Python's dynamic interpreter and runs it at compile time, so operator overloading and other dynamic Python idioms (as used heavily in PyTorch/TensorFlow) can be "lifted" to run before deployment rather than at runtime, and this same interpreter powers "autotuning" — letting a programmer specify a search space of hardware-specific parameters (tile sizes, vector widths) that the compiler empirically benchmarks and caches per target machine, rather than requiring a human hardware expert to hand-tune magic numbers for every new chip.

He walks through where Mojo's demonstrated speedups over standard CPython come from in layers: removing the interpreter (2–5x), getting data out of Python's boxed/reference-counted object representation into registers (another ~10x), and exposing vectorization, threading, and memory-hierarchy control that Python's object model structurally can't expose — compounding toward the 30,000x-plus speedups Mojo has demonstrated on some code, achieved with unmodified Python code in some cases. He is candid that Mojo is very early (he describes it as "0.1," publicly launched only about two weeks before this conversation, with roughly 10,000+ Discord signups and one new user per minute) and still missing basic features (classes, traits/generics, lambda syntax, keyword arguments), a deliberate choice informed by his experience shipping Swift too early at Apple, where a rushed 2014 launch caused significant production instability and community frustration that took years to fully repay; this time, Modular is building in the open, iterating on design (e.g., renaming a keyword after community feedback) before locking in decisions that would be hard to walk back once adopted at scale.

On the relationship between Mojo/Modular and the existing ML ecosystem, Lattner stresses this is not a replacement play: Modular's engine runs underneath existing PyTorch and TensorFlow models to improve performance and deployment without requiring rewrites, and packages that mix Python and C/C++ (a huge source of packaging and tooling pain, in his view) are the natural first candidates to migrate to Mojo, exposing Python-callable interfaces the way Swift eventually exposed interop back to Objective-C. He discusses lessons from his earlier "Swift for TensorFlow" research project (which he considers a valuable but ultimately unsuccessful effort) as clarifying that betting against Python's dominance in ML, or against dynamic "eager mode" style programming (which PyTorch validated and early TensorFlow lacked), is a losing strategy — reinforcing Mojo's decision to work with rather than replace Python's syntax and culture, in contrast to well-regarded alternatives like Julia, which he admires but considers a fundamentally different, non-Python-compatible project.

On AI and the future of programming, Lattner says he isn't worried about near-term AGI or "Skynet" scenarios (partly on the grounds that if such a catastrophe happened he'd be dead and it wouldn't be worth pre-worrying about), and expects technology diffusion for AI to follow the historically slower, messier pattern of past tech rollouts (citing the repeatedly delayed promise of full autonomous driving) even as digital-only AI applications could scale unusually fast. His larger concern is concentration: if frontier model training requires increasingly vast capital (hundreds of millions or billions of dollars), AI capability risks becoming controlled by a small number of well-resourced organizations, and he sees reducing the expertise and infrastructure barrier to deploying AI (analogous to how Python made general programming broadly accessible) as one of the highest-value things the field can do to keep AI development more distributed and widely applicable across niche, specialized domains like radiology. He closes with reflections on hiring and culture at Modular (prioritizing balanced, complementary teams over "hire only 10x engineers," paying competitive salaries, and working hard to counteract the loss of spontaneous in-person bonding in a remote-first company) and career advice emphasizing building real things toward self-set goals over rote study, and deliberately pursuing unfashionable, deeply specialized problems rather than following the herd.

Excerpts