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++.

What about C#?

Another hit-and-run Rust thread!

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

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.

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.

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.

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.

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.

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.

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.

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.

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)?

Maybe the problem is, that you try to learn and use everything at once. Rust is not easy and it has lot of stuff to learn and get good at. And compared to many languages, Rust has a few set of core features that makes it more complicated to understand and also you need to learn the basics before getting started. So just doing the exercises is not enough. My advice is to write simple programs with a focus of specific set of language features and what you want to accomplish, before doing the more advanced stuff.

The difference to languages like C++ is, that Rust forces you to do the homework before running the program, not after. That is the reason why it looks to be “harder”, but I think this is one of the reasons why its so misunderstood. In example if you MUST think about all possible states, variables and errors in a program before it runs, then you have to put so much work for this. In the end, you did all the work and the program should theoretically better than if you did not have. Compare this to other languages, where you can run the program simply by ignoring errors, all states a program can be in and be done in short amount of time. That looks easy. But in reality you didn’t do all the work.

What do you find hard about it?

For me, what made it take so long to learn and really understand was that it’s different from most modern programming languages. It’s not C, C++, or based on my own experiences, C#, JS, Java, etc. Approaching the language as someone who’s really into C# made it difficult to throw away that experience to learn something completely new, whether because I now had to wrap my head around lifetimes or because I can’t have one type inherit the fields and methods of another.

Eventually, if you keep sticking to it (and have interest to do so), you’ll learn how the language was designed to be used, and why it was designed that way.

Reading source code is your friend, by the way. If you want to learn the language, you should spend at least as much time reading code others have written as you also spend writing code. This can be as simple as “go to definition” on some imported function from a library you’re using. Try to understand how that code works, and eventually you’ll even begin to form opinions on what works well vs. what doesn’t. Heck, you might find yourself opening PRs against something like Tauri in no time.

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++