This page lists the people and organizations that have used or are currently
using LLVM in research, education, industry, or open source development. It
only includes users who have publicly discussed their use of LLVM in one form
or another (mentioned it on llvmdev, published work on it, etc.).
We believe there are many other users not listed here and would welcome a brief
note telling us about your use so that we can add you to the list.

This page has only brief entries. Some of these projects are
described in more detail on the
"Projects Using LLVM" page.

Xcode 4.2: "LLVM Compiler 3.0" (aka Clang) now supports many
C++'11 features and libc++ is
supported as a modern C++ runtime library. ARC
is a major new Objective-C feature introduced in this release,
introducing automated memory management to iOS programming. Xcode 4.2
no longer includes GCC 4.2, only the LLVM backend is supported (in the
Clang and llvm-gcc compilers).

Mac OS X 10.7 Lion and iOS5: Virtually all of the code in these
operating systems were built with Clang and llvm-gcc.

Xcode 4.1: LLDB supports debugging iOS devices.

Xcode 4.0: The Clang
parser for C, C++, and Objective-C are now deeply integrated into the Xcode
IDE for code completion, syntax highlighting, indexing, "Edit All In
Scope", and other source code sensitive features. The Clang command line
compiler (known as "LLVM Compiler" in Xcode) also now fully supports C++.
This was the first Apple release of the LLDB Debugger.

Xcode 3.2: Clang is
now included as a production quality C and Objective-C compiler that is
available for use in Xcode or from the command line. It supports X86-32/X86-64
and builds code 2-3x faster than GCC in "-O0 -g" mode. Many "developer tools"
GUI apps were shipped built with Clang, including Xcode, Interface Builder,
Automator, and several others.

Xcode 3.2: The Xcode
Static Analyzer is built on the Clang static
analyzer, and allows Xcode users easy access to the Clang Static Analyzer as
well as a first class user interface to dig through and visualize results.

Mac OS X 10.6: The OpenCL GPGPU implementation is built on Clang and LLVM compiler technology. This
requires parsing an extended dialect of C at runtime and JIT compiling it to run
on the CPU, GPU, or both at the same time. In addition, several performance
sensitive pieces of Mac OS X 10.6 were built with llvm-gcc such as OpenSSL
and Hotspot. Finally, the compiler_rt
library has replaced libgcc and is now a part of libsystem.dylib.

Xcode 3.1: llvm-gcc 4.2
compiler is now available for use in Xcode or from the command line. It
supports PPC32/X86-32/X86-64 and includes transparent LTO integration.

Mac OS X 10.4: Uses the LLVM JIT for optimizing
many parts of the OpenGL pipeline, including emulating vertex/pixel shaders
when hardware support is missing, performing texture format
conversion before uploading to the GPU, efficiently packing GPU buffers
for vertex submission, and many others.