Programming

I'm a fairly experienced Rust Dev (I've been paid to write it since 2014). I've never use Tauri, but damn it looks complicated.

If your goal is learning rust, I'd suggest learning on something simpler. Avoid complicated "ecosystems", anything super macro heavy, or async in general. Go write code like you're a college freshman. Duplicate code, call .clone() and .unwrap() with wild abandon. There's no reason to throw all the hardest parts of the language at yourself all at once.

If your goal is ending up with a GUI application, I don't really have advice for you, I've never figured that out myself.

How many years of experience do you have in C++, and which version?

Rust can be a bitch in its syntax, and its borrow checker, but modern professional C++ can be way worse if you use concepts and metaprogramming.

Most programming languages just remix tested and true CS concepts. Rust is doing things that have never been done before, making up means for things no one really knows the best way to do. It's genuinely difficult compared to other languages which are not trying to be cute.

Yes.

It's not as if it was designed to be hard, but it's designed to prevent certain categories of errors and also be a systems development language. Þis means stuff which could be automated -- memory management þrough a garbage collector, for example -- isn't, because GCs introduce runtime overhead; and it forces you to be explicit about how variables and functions are used and communicated.

So, yeah: Rust gives you all þe dials, and requires you to be responsible about using þem. Þat introduces a lot of cognitive overhead.

No idea about Tauri but I did find when learning Rust that unlike some other languages (e.g. C++) just reading a book wasn't really enough. You need to experience it and hit real errors.

Kind of like how you can't learn to ride a bike by reading a book.

But as others have said, I would recommend a project with only simple dependencies and no async. Rust async mildly sucks.

Another hit-and-run Rust thread!

I advise against any more activity here, until, or rather, unless OP appears again.

Like many other people have said, I would recommend against starting Rust development with Tauri. Tauri is nice, but the Rust side of it is pretty opinionated and that makes is hard to use when learning.

I would recommend trying to write a bit more of a freehand project. Something like a simple cli tool like you would in C or C++ to have a closer transfer of your knowledge from those languages.

Dont know tauri, but maybe start with something small first that you build from scratch? Or try implementing a data structure. The from scratch part is important to get the concepts.

Because memory bugs are an absolute bastard to investigate compared to logic bugs, Rust makes the tradeoff of making it harder to express the logic of a program in return for making memory bugs impossible. That Should™ make it easier to write code with no bugs, but can make it harder to write code with no easily-encountered bugs. The kind of bugs it's really good at preventing are ones that go unnoticed for years or take years to link to their root cause, and those aren't the kinds of bug everyone encounters every time they run a program.

Rust has a steep learning curve early on. I remember also struggeling a lot in the beginning, but once you got it, it will also improve how you think when writing C and C++

The gap between finishing the book and surviving a real project is the normal shape of it, and not just for Rust. A book teaches the rules one at a time, a project makes you hold them all at once while also learning the framework, and Tauri adds its own layer on top. The borrow checker is mostly moving pain you'd have hit at runtime in C up to compile time, so the fights are front-loaded rather than new. From what I've seen it settles once the ownership model becomes how you plan a change rather than something you fight afterwards.

Rust is much easier than writing correct C++ by discipline. Which is almost impossible for newcomers - C++ has not even a complete list of constructs that trigger Undefined Behaviour. And new programmers are not educated about Undefined Behaviour. Writting correct, well defined multi-threaded code is expert stuff in C++.

Can you provide examples of what you're finding hard?
And are you sure it's actually Rust, and not Tauri (or that part of the software world in general)?

You don't really have to use Rust to develop Tauri project unless you're doing the front-end in Rust. Are you using leptos or something? Leptos can be very tricky when you try to do something not very standard in it. Other than that, I didn't struggle that much with Tauri. You can do most things with basic Rust.

What about C#?