rust VS carbon-lang

Compare rust vs carbon-lang and see what are their differences.

rust

Empowering everyone to build reliable and efficient software. (by rust-lang)

carbon-lang

Carbon Language's main repository: documents, design, implementation, and related tools. (NOTE: Carbon Language is experimental; see README) (by carbon-language)
Stream - Scalable APIs for Chat, Feeds, Moderation, & Video.
Stream helps developers build engaging apps that scale to millions with performant and flexible Chat, Feeds, Moderation, and Video APIs and SDKs powered by a global edge network and enterprise-grade infrastructure.
getstream.io
featured
InfluxDB – Built for High-Performance Time Series Workloads
InfluxDB 3 OSS is now GA. Transform, enrich, and act on time series data directly in the database. Automate critical tasks and eliminate the need to move data externally. Download now.
www.influxdata.com
featured
rust carbon-lang
2,859 187
105,041 33,060
1.2% 0.6%
10.0 9.9
5 days ago 4 days ago
Rust C++
GNU General Public License v3.0 or later GNU General Public License v3.0 or later
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.

rust

Posts with mentions or reviews of rust. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2025-07-18.
  • Towards Sub-100ms Latency Stream Processing with an S3-Based Architecture
    4 projects | dev.to | 18 Jul 2025
    RisingWave is a high-performance streaming database built in Rust. It’s PostgreSQL-compatible and lets users write sophisticated stream processing logic using standard SQL - no need to learn a new DSL or framework.
  • Why Developers Are Switching to Rust: The Rise of Rust Development in 2025
    1 project | dev.to | 15 Jul 2025
    Rust development is experiencing major growth in 2025 as its developers continue to focus more on performance, memory safety, and reliability of their code. Supported by a powerful compiler, with modern tooling and an emerging ecosystem, Rust is an alternative to the majority of the limitations of legacy systems programming languages. This blog discusses the theoretical basis behind the transition to Rust-based development and the reasons why it is rapidly growing as an attractive option to software engineers and organizations.
  • Rust Cargo: The Backbone of Rust Development
    2 projects | dev.to | 14 Jul 2025
    https://www.rust-lang.org/ https://doc.rust-lang.org/cargo/ https://doc.rust-lang.org/cargo/getting-started/installation.html
  • Tree Borrows
    9 projects | news.ycombinator.com | 9 Jul 2025
    I am very sorry, but you do not address that TBAA, like C has by default, generally is easier than just no aliasing, like what Rust has for mutable references. This is a major difference. C code can opt into a similar kind of aliasing, namely by using _restrict_, but that is opt-in, while it is always on for Rust.

    And there is newer UB as well in Rust stdlib

    https://github.com/rust-lang/rust/pull/139553

  • # [derive(Clone)] Is Broken
    11 projects | news.ycombinator.com | 8 Jul 2025
  • My first verified (imperative) program
    2 projects | news.ycombinator.com | 7 Jul 2025
    Real-world programs can be verified by formally proving properties on a small part of the code (called the kernel) in a way that transitively guarantees those for the remaining code.

    For example, Rust's borrow checker guarantees* memory safety of any code written in Rust, even a 10M+ LOC project. Another example is sel4, a formally-verified micro-kernel (https://sel4.systems/About/seL4-whitepaper.pdf).

    * Technically not; even if the code doesn't use `unsafe`, not only is Rust's borrow checker not formally verified, there are soundness holes (https://github.com/rust-lang/rust/issues?q=is%3Aopen%20is%3A...). However, in theory it's possible to formally prove that a subset of Rust can only encode memory-safe programs, and in practice Rust's borrow checker is so effective that a 10M+ LOC project without unsafe will still probably not have memory issues.

  • The Technology Behind SmoothCSV - The Ultimate CSV Editor
    13 projects | dev.to | 30 Jun 2025
    Backend: Rust
  • Weird Expressions in Rust
    4 projects | news.ycombinator.com | 27 Jun 2025
    What's weird about this?

    To understand what evil_lincoln is doing, you have to understand very old Rust. Here's the commit that introduced it: https://github.com/rust-lang/rust/commit/664b0ad3fcead4fe4d2...

        fn evil_lincoln() {
  • "Why is the Rust compiler so slow?"
    7 projects | news.ycombinator.com | 26 Jun 2025
    Side note: There's an effort to cache proc macro invocations so that they get executed only once if the item they annotate hasn't changed: https://github.com/rust-lang/rust/pull/129102

    There are multiple caveats on providing this to users (we can't assume that macro invocations are idempotent, so the new behavior would have to be opt in, and this only benefits incremental compilation), but it's in our radar.

  • Naked functions are now stable in Rust 1.88
    1 project | news.ycombinator.com | 23 Jun 2025

carbon-lang

Posts with mentions or reviews of carbon-lang. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2025-05-06.
  • Initialization in C++ is bonkers (2017)
    1 project | news.ycombinator.com | 15 May 2025
    The latest Carbon newsletter is here, from March: https://github.com/carbon-language/carbon-lang/discussions/5...
  • Matt Godbolt sold me on Rust (by showing me C++)
    14 projects | news.ycombinator.com | 6 May 2025
    There has been talk of new language frontends for C++:

    Cpp2 (Herb Sutter's brainchild): https://hsutter.github.io/cppfront/

    Carbon (from Google): https://github.com/carbon-language/carbon-lang

    In principle those could enable a safe subset by default, which would (except when explicitly opted-out) provide similar safety guarantees to Rust, at least at the language level. It's still up to the community to design safe APIs around those features, even if the languages exist. Rust has a massive advantage here that the community built the ecosystem with safety in mind from day 1, so it's not just the language that's safe, but the APIs of various libraries are often designed in an abuse-resistant way. C++ is too much of a zoo to ever do that in a coherent way. And even if you wanted to, the "safe" variants are still in their infancy, so the foundations aren't there yet to build upon.

    I don't know what chance Cpp2 or Carbon have, but I think you need something as radical as one of these options to ever stand a chance of meaningfully making C++ safer. Whether they'll take off (and before Rust eats the world) is anyone's guess.

  • Kickstart insight needed: A new retrofitted C dialect?
    14 projects | news.ycombinator.com | 22 Feb 2025
    Kind of along these lines but for C++: https://docs.carbon-lang.dev/
  • Greg Kroah-Hartman Makes Compelling Case for Kernel Drivers Be Written in Rust
    3 projects | news.ycombinator.com | 20 Feb 2025
    2. There are certain safety problems that simply can't be solved in C++ unless you accept that ABI will be broken and the language won't be backwards compatible.

    Circle (https://www.circle-lang.org/site/index.html) and Carbon (https://docs.carbon-lang.dev/) were both started to address this fundamental issue that C++ can't be fully fixed and made safe like Rust without at least some breaking changes.

    This article goes into more depth: https://herecomesthemoon.net/2024/11/two-factions-of-cpp/

    In the case of the Linux kernel, a lot of the newer features that C++ has delivered aren't _that_ useful for improving safety because kernel space has special requirements which means a lot of them can't be used. I think Greg is specifically alluding to the "Safety Profiles" feature that the C++ committee looks like it will be going with to address the big safety issues that C++ hasn't yet addressed - that's not going to land any time soon and still won't be as comprehensive as Rust.

  • Carbon Copy Newsletter No.5
    1 project | news.ycombinator.com | 16 Dec 2024
  • The Two Factions of C++
    15 projects | news.ycombinator.com | 24 Nov 2024
    People like to always talk about Carbon like that, yet the team is the first to point out anyone that can use something else, should.

    Carbon is an experiment, that they aren't sure how it is going to work out in first place.

    > "If you can use Rust, ignore Carbon"

    https://github.com/carbon-language/carbon-lang/blob/e09bf82d...

    > "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 communit"

    https://github.com/carbon-language/carbon-lang/blob/e09bf82d...

  • Is Carbon Language Moving Towards Success or Self-Destruction? A Case Study in Rapid Deployments
    2 projects | dev.to | 17 Sep 2024
    The Carbon Language repo on GitHub maintains an impressive deployment frequency, consistently pushing updates at a rapid pace. With an average of over 74.67 deployments per month---hitting 79 in July 2024 alone---Carbon is setting the pace for fast, efficient software delivery. But is there a price for going this fast?
  • What's new in C++26 (part 1)
    6 projects | news.ycombinator.com | 7 Sep 2024
    I for one started working on a new project in C++ rather than Rust. I think it's unclear whether Rust is going to be the successor at this point. It's probably never going to pick up in the games industry, QT is C++ (and Rust bindings will always be second class or they could end up unmaintained), has better compile times and is said to be undisputed when it comes to high performance. Obviously the tool for the job factor is most critical.

    Career wise, many people are picking up Rust and almost no one is picking up C++, while experienced C++ devs either retire or switch to a higher level language due to landscape change. I would trust supply and demand to be in favour of C++ 10 years from now.

    There are also attempts to make C++ more memory safe like Carbon[1] or Circle compiler [2]. If they succeed, why would anyone want to switch to Rust? Also Rust is not ideal for security from a different perspective - I think the lack of a package manager is one C++ strongest points. After working for 9 years with npm, you really appreciate that the dependency you install is usually just a single dependency (even an option for a single header file is common), when there's a package manager, people will abuse it (like install a package with 3 dependencies of its own for something that could be 50 LOC copy-paste) and managing the security of the supply chain is nearly impossible (it will be a legal requirement soon in EU though).

    Anyway, I wanted to ask. How is the contracting market looking in C++ world? I'm guessing it depends on the domain heavily? I'm mainly asking about QT and anything that would be desktop / mobile apps / systems programming except video games, but I'm curious in general.

    [1] https://github.com/carbon-language/carbon-lang

    [2] https://github.com/seanbaxter/circle

  • Carbon Copy Newsletter No.3
    1 project | news.ycombinator.com | 20 Jun 2024
  • Circle C++ with Memory Safety
    2 projects | news.ycombinator.com | 2 Jun 2024
    Thanks for clarifying that point. It's worth pointing out that the safety strategy doc[0] mentions that

    >A key subset of safety categories Carbon should address are:

    >[...]

    >Data race safety protects against racing memory access: when a thread accesses (read or write) a memory location concurrently with a different writing thread and without synchronizing

    But then later in the doc it says

    >It's possible to modify the Rust model several ways in order to reduce the burden on C++ developers:

    >Don't offer safety guarantees for data races, eliminating RefCell.

    >[...]

    >Overall, Carbon is making a compromise around safety in order to give a path for C++ to evolve. [...]

    One could read this as saying that guaranteed safety against data races is not a goal. Perhaps this doc could be reworded? Maybe something like "Carbon does not see guaranteed safety against data races as strictly necessary to achieve its security goals but still we still currently aim for a model that will prevent them."

    [0] https://github.com/carbon-language/carbon-lang/blob/trunk/do...

What are some alternatives?

When comparing rust and carbon-lang you can also consider the following projects:

zig - General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.

Odin - Odin Programming Language

hylo - The Hylo programming language

Nim - Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula. Its design focuses on efficiency, expressiveness, and elegance (in that order of priority).

cppfront - A personal experimental C++ Syntax 2 -> Syntax 1 compiler

Stream - Scalable APIs for Chat, Feeds, Moderation, & Video.
Stream helps developers build engaging apps that scale to millions with performant and flexible Chat, Feeds, Moderation, and Video APIs and SDKs powered by a global edge network and enterprise-grade infrastructure.
getstream.io
featured
InfluxDB – Built for High-Performance Time Series Workloads
InfluxDB 3 OSS is now GA. Transform, enrich, and act on time series data directly in the database. Automate critical tasks and eliminate the need to move data externally. Download now.
www.influxdata.com
featured

Did you know that Rust is
the 5th most popular programming language
based on number of references?