nico VS autocxx

I think everything depends on the scale of your ideas, see https://johanpeitz.itch.io/picocad You can make something similar with Nico https://github.com/ftsf/nico :)

Game framework: Nim + Pico-8 = Nico

I love making games with Nico: https://github.com/ftsf/nico

Concise and readable, small binaries, fast compile times, native performance, zero-overhead interop lets you reuse code in C, C++, JS, Objective-C, Python... Does a programming language have these fantastic features? Of course, Nim language does have the features I have been dreaming about. And what is the goal of Nim language? Simply put, the goal is "one language to rule them all", from shell scripting to web frontend and backend, scientific computing, deep learning, blockchain client, gamedev, embedded.

Something to look at if you want to encourage simple game development is supporting PICO-8 [0], or the compiled Nim version Nico [1].

[0]: https://www.lexaloffle.com/pico-8.php?page=faq

[1]: https://github.com/ftsf/nico

Some more fun high level frameworks:

- HaxeFlixel (https://haxeflixel.com/) (Extremely portable)

- Phaser (https://phaser.io/) (HTML5 framework)

- Nico (https://github.com/ftsf/nico) (The PICO-8 API in Nim)

- Pixel Vision 8 (https://pixelvision8.github.io/PixelVision8Website/) (Another fantasy console)

Meanwhile, one of the best C++ sources which community mostly think of - Chromium - starting to experience with Rust. If i'm not mistaken using https://github.com/google/autocxx

There's bindgen, cxx and autocxx. Obviously not as convenient as C++ calling C++; the more you need to interoperate with C++ code the more it makes sense to just stay with C++.

If you want to reach the author for a correction, perhaps leave a comment on the Medium post or perhaps mention it on the autocxx PR I found this article from.

Rust and C++ are not directly interoperable, but you can try to use some fancy libraries if your C++ codebase is simple. Google is taking on this gargantuan task with autocxx. I believe it is related to their exploration efforts to bring Rust to Chrome.

I used autocxx in a recent project and was amazed at how easy it was to call into C++ -- Rust Analyzer was even able to provide completion hints.

Sure, they can improve C++ interop - and they have been - but that doesn't help them maintain the dozens of millions of lines of C++ they (Google, and others) currently have. Carbon is a pragmatic solution to the state of affairs in C++ that doesn't require them to rewrite all of their existing code to improve its maintainability.

The areas you mentioned (CLI, web services, low level systems programming) are not mutually exclusive. Doing a good job on one doesn't mean something else is affected.

The folks who worked on the most popular command line argument parser (https://docs.rs/clap/latest/clap/#example) made a positive contribution that didn't detract from any other use case.

Similarly, the folks working on improving Rust for web services will also make it better for systems programming. In a blog post published today (https://blog.rust-lang.org/inside-rust/2022/07/27/keyword-ge...), they discuss keyword generics, a feature that will be equally helpful for `async` code and `const` functions evaluated at compile time.

There is already some interoperability with C++ (http://cxx.rs) and ongoing research into automating this interoperability (https://github.com/google/autocxx, https://github.com/google/crubit). Feels like there's enough effort

That's not at all in Rust's bill, it needs an interaction layer to talk to C++. Efforts like cxx (and google's own autocxx) try to make this layer more automated and less painful, but the layer is still there, it still has a cost, and it doesn't erase the impedance mismatches between the languages.

Notably Google is also investing in autocxx to make C++/Rust bidirectional interoperation easier

Again, not really...? A lot of the proposed ABI changes (for C++ - I don't know what they're planning for Carbon) are trivial to automatically fix if you have source access. If you don't have source access, you "only" need to maintain the ABI at the boundaries between foreign code and your code, which is quite possible (especially after the success of autocxx and related projects in the Rust <-> C++ world)