Quoting from README:

Carbon Language:
An experimental successor to C++

Why? | Goals | Getting started | Join us

Quicksort code in Carbon. Follow the link to read more.

Fast and works with C++

Modern and evolving

Welcoming open-source community

Why build Carbon?

C++ remains the dominant programming language for performance-critical software,
with massive and growing codebases and investments. However, it is struggling to
improve and meet developers' needs outlined above, in no small part due to
accumulating decades of technical debt. Incrementally improving C++ is
extremely difficult, both due to
the technical debt itself and challenges with its evolution process. The best
way to address these problems is to avoid inheriting the legacy of C or C++
directly, and instead start with solid language foundations like a
modern generics system, modular code organization, and consistent,
simple syntax.

Existing modern languages already provide an excellent developer experience: Go,
Swift, Kotlin, Rust, and many more. Developers that can use one of these
existing languages should.
Unfortunately, the designs of these languages
present significant barriers to adoption and migration from C++. These barriers
range from changes in the idiomatic design of software to performance overhead.

Carbon is fundamentally a successor language approach, rather than an
attempt to incrementally evolve C++. It is designed around interoperability with
C++ as well as large-scale adoption and migration for existing C++ codebases and
developers. A successor language for C++ requires:

With this approach, we can build on top of C++'s existing ecosystem, and bring
along existing investments, codebases, and developer populations. There are a
few languages that have followed this model for other ecosystems, and Carbon
aims to fill an analogous role for C++:

Language Goals

We are designing Carbon to support:

While many languages share subsets of these goals, what distinguishes Carbon is
their combination.

We also have explicit non-goals for Carbon, notably including:

Our detailed goals document fleshes out these ideas
and provides a deeper view into our goals for the Carbon project and language.

Project status

Carbon is currently an experimental project. We want to better understand
whether we can build a language that meets our successor language criteria, and
whether the resulting language can gather a critical mass of interest within the
larger C++ industry and community.

Currently, we have fleshed out several core aspects of both Carbon the project
and the language:

Full roadmap for more details.

Carbon and C++

If you're already a C++ developer, Carbon should have a gentle learning curve.
It is built out of a consistent set of language constructs that should feel
familiar and be easy to read and understand.

C++ code like this:

A snippet of C++ code. Follow the link to read it.

corresponds to this Carbon code:

A snippet of converted Carbon code. Follow the link to read it.

You can call Carbon from C++ without overhead and the other way around. This
means you migrate a single C++ library to Carbon within an application, or write
new Carbon on top of your existing C++ investment. For example:

A snippet of mixed Carbon and C++ code. Follow the link to read it.

Read more about
C++ interop in Carbon.

Beyond interoperability between Carbon and C++, we're also planning to support
migration tools that will mechanically translate idiomatic C++ code into Carbon
code to help you switch an existing C++ codebase to Carbon.


Carbon provides a
modern generics system
with checked definitions, while still supporting opt-in
templates for seamless C++ interop
. Checked
generics provide several advantages compared to C++ templates:

Without sacrificing these advantages, Carbon generics support
, ensuring it can fully address performance-critical use cases
of C++ templates. For more details about Carbon's generics, see their

In addition to easy and powerful interop with C++, Carbon templates can be
constrained and incrementally migrated to checked generics at a fine granularity
and with a smooth evolutionary path.

Memory safety

Safety, and especially
memory safety, remain key
challenges for C++ and something a successor language needs to address. Our
initial priority and focus is on immediately addressing important, low-hanging
fruit in the safety space:

Once we can migrate code into Carbon, we will have a simplified language with
room in the design space to add any necessary annotations or features, and
infrastructure like generics to support safer design patterns.
Longer term, we will build on this to introduce a safe Carbon subset. This
will be a large and complex undertaking, and won't be in the 0.1 design.
Meanwhile, we are closely watching and learning from efforts to add memory safe
semantics onto C++ such as Rust-inspired
lifetime annotations.

Getting started

You can get started playing with Carbon by checking out the codebase and using
the Carbon explorer:

# Install bazelisk using Homebrew.
$ brew install bazelisk

# Install Clang/LLVM using Homebrew.
# Many Clang/LLVM releases aren't built with options we rely on.
$ brew install llvm
$ export PATH="$(brew --prefix llvm)/bin:${PATH}"

# Download Carbon's code.
$ git clone
$ cd carbon-lang

# Build and run the explorer.
$ bazel run //explorer -- ./explorer/testdata/print/format_only.carbon

Tags: native   object   llvm  

Last modified 03 October 2022