Something something history is a flat circle

Has Carbon been used anywhere noticeable? Last time I heard of it was when Google announced it few years ago, haven't seen anything getting written or ported to it, though I haven't read much into it so I might have missed many news.

It looks like a nice mix of some of the worst design choices of C++ with some of the most dubious choices of Rust.
- Oh, so it's a contender against Brainfuck
I actually completely forgot it was a thing. I haven't heard anything about it either since it was announced

Relevant comment

I don't use Rust much, but I agree with the thrust of the article. However, I do think that the borrowchecker is the only reason Rust actually caught on. In my opinion, it's really hard for a new language to succeed unless you can point to something and say "You literally can't do this in your language"
Without something like that, I think it just would have been impossible for Rust to gain enough momentum, and also attract the sort of people that made its culture what it is.
Otherwise, IMO Rust would have ended up just like D, a language that few people have ever used, but most people who have heard of it will say "apparently it's a better safer C++, but I'm not going to switch because I can technically do all that stuff in C++"

D has a lot of other reasons why it haven't caught on.
The language is way too similar to both C and C++. In fact, you can get C and C++ code working in D with minimal changes (most annoying part is int meaning different things in both languages), and nowadays I can pull the conversion off on the regular. It's like the only changes that were made to the language are making things more consistent, making things work better. etc. Rust is more like a language that is a marriage between C-style languages and OCaml. Rust is also a "functional first" language with the ability of opting out from the functional part, first when I've heard about Rust it was through this "fancy and new programming paradigm, that promises to fix everything wrong with programming", and the D team wanted to be left out from making const the default mutability.
The GC sounds scary for most people, who want to develop desktop applications. It's rapid fast, will be even faster soon, and there's tricks to either opt-out from it, or to get a @nogc thread going (using that for audio).
Marketing issues. Walter Bright, while a genius compiler developer, is not a good marketing person.
Formerly D was quite infamous for its toxic users, with Walter going infamous for his "let nazis code" line for a while. Allegedly, most of the toxicity moved over to openD, which made some people question why Adam D. Ruppe forked the language.
The whole shenanigans around moving from D1 to D2, also Tango.
- moving from D1 to D2
  I was learning a few different languages at the time, and it's a bit fuzzy in my head, but I remember the confusion between the 2 compilers. One was incomplete and/or obsolete, and the other one was in beta or something and you shouldn't use it anyway. I chose nothing and tried something else because it was annoying to watch. Walter, as the BDFL, should have decided on something but it never arrived, and the hype went away.
  All I remember is that some Japanese guy wrote a bullet-hell library and game in D, and that was great. But the community was too confusing for me.
I kinda disagree. The reason rust caught on is because it is much safer than C++ while having the same or even better performance. And in some contexts, being garbage collected means bad performance.
Before rust you could either have a fast language (C/C++) or a memory safe language (any other language. That is, languages with garbage collector). But if you required memory safety and peak performance, there wasn't any option.
Yes, the reason that rust is both memory safe and fast is because it has a borrow checker. But the borrow checker is the means, not the end.
- Garbage collection doesn't guarantee memory safety and it's perfectly possible to create a memory-safe language without garbage collection. There are plenty of garbage collectors for C++ (and until C++23, support for garbage collection was part of the standard, although no one implemented it), and languages like C# let you interact with garbage-collected objects in unsafe blocks.
- At one point long ago (just for a short while), I thought Delphi was destined to take that place. It was much higher level while still letting you go as low level as you wanted- it didn't have garbage collection but it made it pretty easy to keep track of what is or isn't allocated, on top of having good tools to find leaks on runtime. But it had too many problems too: the Pascal base and the association with drag and drop coders being some of the first ones, followed by a series of bad decisions by whatever company was responsible for it at any given week.
- The "better" performance is due to the built-in multi-threading support, and that functional programming makes it relatively safer to pull off. Otherwise single-threaded Rust is very hard to optimize.
“apparently it’s a better safer C++, but I’m not going to switch because I can technically do all that stuff in C++”
The main difference between C++ and D was that (for most of the time in the past) D required a garbage collector.
So, D was a language with similar Algol-style syntax targeting a completely different niche from C++.
Trying to correct your quote, it should read something like "I’m not going to switch because I can't technically do all that stuff in D that I'm doing in C++" for it to make any sense.
- “Before rust you could either have a fast language (C/C++) or a memory safe language (any other language. That is, languages with garbage collector).”
  Ada managed to do safe and fast over forty years ago.
Yep, and that's not a bad thing. Switching has a cost, and using the old standby is probably the way to go if there's a bunch of new things, none of which are definitely, inarguably better than it.

K&R started with BCPL as their base of inspiration. They then made B, and then C. The followup should be called P.

Some people really suck at coming up with names for their programming languages. There are so many single letter languages (B, C, D, E, F, J, K, V...) that it really makes one wonder what the fuck is wrong with them
- These days, search engine optimization tends to force new single letter languages into obscurity. Even Go would have issues there if Google hadn't been behind it.
https://en.m.wikipedia.org/wiki/P_(programming_language)
- Lies!

Go?

that was the stated goal, at first. to replace C for writing os services.
- yeah, C, not C++.

I tried programming in D a little. Wasn't bad. Just up against industry giants.

That's the best part, it's not made for industry specs!

Zig or V could've been shown instead of Carbon (the lone C)