ritual VS autocxx

For your inspiration to get c++ code in a crate: https://github.com/rust-qt/examples uses ritual build https://github.com/rust-qt/ritual which integrates qt c++ stuff into the above cargo qt rust examples. I would like to highlight the todo list example. Build and run it verbosely with "--verbose --verbose".

It is great to see how many people want to bring Qt support to Rust and are trying to do so, and I hope that these folks succeed, but it’s wearisome to me how they each create a new project instead of working with others who are already in this problem space. Of the half-dozen or so[0] existing attempts so far to create Qt bindings to Rust, none of them have actually succeeded because they’ve either been abandoned midway or limit their support to QML. Ritual[1] is the only crate I’ve seen that attempts to actually expose the whole Qt API, but it’s pretty awful to use, incomplete, and dead.

Rust doesn’t need more Qt crates. It needs one Qt crate that is complete and works well. (Or, ideally, a native Rust cross-platform GUI crate that works as well as Qt, but that’s an even longer and harder task.)

[0] https://lib.rs/search?q=qt

[1] https://github.com/rust-qt/ritual

Just wanted to add another vote for https://github.com/rust-qt/ritual that 0OOO00000OO00O0O0OOO/ mentioned below.

There was a QT library, rust-qt (that was officially supported I believe), the bindings being made with Ritual. There is an open issue for supporting qt6, which I'm also awaiting; https://github.com/rust-qt/ritual/issues/109.

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)