This was last updated in June 2025, and may be out of date. If you have questions, please contact me.
Email: clattner@nondot.orgI am an innovator well-known for building multiple large-scale production systems that are used by millions of people, as well as building teams and communities that make them possible. I cofounded the LLVM Compiler infrastructure, the Clang compiler, the Swift programming language, the MLIR compiler infrastructure, the CIRCT project, and have contributed to many other commercial and open source projects at Apple, Tesla, Google, and SiFive.
I lead Modular AI, and serve on the board of directors of the LLVM Foundation.
Modular AI has a bold mission and is rapidly growing!
I joined SiFive in January 2020, right before the COVID pandemic struck. In the summer of 2020, the board decided to make major changes to the company (“SiFive 2.0”) - separating management of the silicon services team (initially known as OpenFive, later sold off to Alphawave) from SiFive’s RISC-V endeavors, hiring a new CEO, and rebooting the RISC-V organization. I stepped up to lead the RISC-V Product and Engineering organizations (everything excluding HR, finance, sales, customer support). My major accomplishments over this time are:
I'm proud of this progress and the path ahead for SiFive is very strong. The team and mission are very dear to me, and I maintained a formal advisor relationship with SiFive’s leadership and chip design team through 2023. I continue to be amazed by SiFive’s passion, drive, and rapid growth.
The TensorFlow group is a dynamic and fast moving team, incorporating multiple cross-cutting concerns that I loved to work on and with. This included complex product issues, Open Source infrastructure, deep technical challenges, new hardware platforms, and a race with the rest of the industry. These are the main projects that I advocated for, built, and scaled:
TensorFlow Infrastructure Team: I led the TensorFlow Infrastructure team, which included responsibility for TensorFlow's CPU, GPU, TPU ("Tensor Processing Units"), and mobile infra. This involves a wide range of compiler and runtime technologies, including the XLA compiler team, TensorFlow graph transformations, quantization technologies, kernels written with Eigen and other approaches, etc.
The MLIR Compiler Infrastructure: MLIR is an open source compiler infrastructure that underlies TensorFlow, providing support for a very wide range of high performance accelerators. The need is driven by requirements for better usability, integration, and increased generality of the stack. This work is particularly important as the "End of Moore's Law" leads to a proliferation of new hardware, which needs software support: rapid bringup is essential, even with occasionally wildly different capabilities and target markets. This is a large scale project pushing the boundaries of fundamental compiler technology - building on decades of experience building compilers.
MLIR is defined in a framework-agnostic way and is successfully aligning the largest hardware manufacturers in the world. For more information, see the announcement and the intro talk. Google contributed MLIR to the non-profit LLVM Foundation, which contributed to its rapid industry-wide adoption.
TensorFlow "TFRT" Runtime: I led the charge to build a next-generation runtime for TensorFlow. The goal of the runtime is to provide a single consistent platform that dramatically increased performance and flexibility, which supports both training and inference, server and mobile. I defined the architecture and led the implementation (i.e. wrote most of the code) and overall design.
Swift for TensorFlow: This project rethought machine learning development by opening the programming language to extension and change - allowing us to solve old problems in new ways. This project includes a combination of compiler, runtime, and programming language design and implementation work. I imagined, advocated for, coded the initial prototype and many of the subsystems after that; recruited, hired and trained an exceptional engineering team; we drove it to an open source launch as well as many subsequent milestones (including internal launches that shipped on all Android Pixel phones). For more information, see the MLSys paper that summarizes the project.
In addition to leading large teams of exceptional engineers, my roles at Google included designing and implementing many technologies from first principles, hiring the engineering team and building the engineering culture around them, and growing the engineering leaders who eventually took them over and continue driving them today. I consider myself very privileged to be able to work with such an amazing team and to be able to build such fundamental technologies in a critical and fast-paced community.
When I joined Tesla, it was in the midst of a hardware transition from "Hardware 1" Autopilot (based primarily on MobileEye for vision processing) to "Hardware 2", which uses an in-house designed TeslaVision stack. The team was facing many tough challenges given the nature of the transition. My primary contributions over these fast five months were:
Overall I learned a lot, worked hard, met a lot of great people, and had a lot of fun.
In January 2013, I took over management and leadership of the entire Developer Tools department at Apple (~200 people). In addition to languages (Swift and Objective-C), compilers and low-level tools, I took on responsibility for the Xcode IDE, Instruments performance analysis tool, Apple Java releases, and a variety of internal tools.
In this time period, my team shipped a number of major Xcode releases, including Xcode 4.6, 5.x, 6.x, 7.x, and 8.x, each with major feature enhancements. Some of my more notable contributions include:
This timeframe has included numerous technical and team achievements across a wide range of domains. For example:
I managed the teams responsible for compilers, the LLDB debugger, Objective-C and C++ runtimes, assembler, linker, dynamic loader, etc. I am continuing my work improving the Apple developer tools, and continue to contribute daily to the open source LLVM technologies. During this time period my team switched Mac OS/X Lion and iOS5 to build with llvm-gcc and clang (off of GCC 4.2) and oversaw the final release of Xcode 4.0 in March (as well as subsequent updates).
Xcode 4.2 was a specific achievement in that it is the first release where all of its compilers are LLVM-based (GCC 4.2 is no longer included). Xcode 4.2 also includes the "Automatic Reference Counting (ARC) Objective-C language feature (see also wikipedia). ARC has revolutionized Objective-C programming by automating memory management without the runtime overhead of a garbage collector. I personally defined and drove this feature late in the schedule of iOS5 and Lion. This is notable for the short schedule for the project, the extensive cross-functional work required, and the extensive backwards compatibility issues that had to be addressed (making it a very technically complex problem).
My work in this time period culminated in the release of the Xcode 4 preview at WWDC, which included a preview release of Clang C++ support, a new C++ Standard Library, a much faster and memory efficient system linker, a new X86 assembler (which is integrated into the clang compiler, providing faster compile times), and countless smaller improvements throughout the toolchain.
Xcode 4 itself now features deep integration of the Clang parser for code completion, syntax highlighting, indexing, live warning and error messages, and the new 'Fix-It' feature in which the compiler informs the UI how to automatically corrects small errors. LLVM-GCC is the default compiler in Xcode 4.
The Xcode 4 preview also includes the first public release of LLDB to which I served as a consultant and contributed directly to turning it into an open source project.
In this time period, I was a second level manager running the teams responsible for Clang, LLVM, GCC, and other parts of the Apple toolchain (assembler, linker, etc). I directly managed the Clang team, contributed daily to both the Clang and LLVM projects, and continued in my role as compiler architect and lead on the Open Source LLVM/Clang projects.
During this period my team brought Clang 1.0 to production quality as a brand new C and Objective-C compiler for X86-32 and X86-64. We also productized and shipped the Xcode static analyzer, a new compiler-rt library (which replaced libgcc in Snow Leopard) and many enhancements to existing components in the operating system.
In this time period, my group expanded use of LLVM within Apple, supported new clients, built new features, and extended LLVM in many ways. We shipped llvm-gcc 4.2 in the Xcode 3.1 and major improvements for it in the Xcode 3.1.1 release.
In addition to llvm-gcc, much of the work during this time was focused on Mac OS 10.6 development. I made major contributions to design and implementation of the "Blocks" language feature as well as to the architecture and design of the language and compiler aspects of the OpenCL GPGPU technology.
Finally, during this period I architected and started implementation of a suite of front-end technologies based on LLVM, named "Clang".
I drove LLVM productization, features and applications at Apple. LLVM link-time optimization support is now integrated into the Apple system linker, and LLVM is used by the Apple OpenGL group for several different purposes. My main contributions during this time was a new llvm-gcc4 front-end, significant improvements to the X86 and PowerPC backends, a wide range of optimization improvements and new optimizers, significant improvement to the target-independent code generator, and leadership for the rest of the team.
I worked on numerous projects at UIUC, the most important being LLVM and Data Structure Analysis (DSA). At Illinois, I designed and built most of the fundamental aspects of LLVM, establishing the architecture for things to come and building most of the scalar, loop and interprocedural optimizers. I also built most of the target-independent code generator, X86 backend, JIT, llvm-gcc3 front-end, and much more. Finally, I wrote many papers.
I worked on the Microsoft Phoenix compiler infrastructure, building an experimental bridge between the Microsoft compiler and the LLVM compiler (which allowed LLVM to compile and run .NET code).
University of Illinois, Urbana-Champaign - Urbana, Illinois - GPA: 4.0
University of Portland - Portland, Oregon - GPA: 3.9
Here are some of the more interesting things I've written:
Notable awards:
Since joining industry, I rarely take time to write papers about my work, preferring instead to focus on building new great things. That said, I've had the opportunity to colaborate on the following papers:
In addition to technical activities: