For the past while, I’ve been dabbling more and more with Rust.
I don’t think I ever really decided, “Okay, now I’m going to learn Rust.”
It happened a lot more naturally than that.
I tried it. I liked some things about it. Then I started using Tauri. Then I built another thing with Tauri. And another.
Somewhere along the way, Rust started showing up in a pretty significant chunk of the stuff I was making.
TypeScript is still very much home for me, and a lot of what I build these days is some combination of React, TypeScript, and Rust rather than pure Rust.
But apparently Rust has worked its way into my toolbox.
And I’m kind of loving it.
Tauri probably had a lot to do with it
Tauri has become one of my favorite things to build with lately.
It lets me keep using React and TypeScript for the parts I already know well while slowly getting pulled further and further into Rust on the native side.
Filesystem stuff, SQLite, processes, system integration, whatever weird desktop thing I’ve decided the app needs this time.
For me, that’s been a really good way to learn.
I’m not sitting there doing random ownership exercises because chapter six of a tutorial told me to.
I’m trying to make an actual app do something, discovering that I have absolutely no idea how to do that thing in Rust, and then figuring it out.
That tends to stick in my brain a lot better.
A bunch of my recent projects have ended up working this way.
Command Center started because I wanted a better way to keep track of terminal commands and scripts I use or want to remember. It turned into a Tauri desktop app with React and TypeScript on the frontend and Rust handling a lot of the native stuff underneath.
Quota ended up going the same direction. I originally made it because I wanted one place to keep an eye on usage across the different AI coding tools I use, and now it has both a desktop app and VS Code extension. The desktop app is another Tauri/Rust/React/TypeScript situation.
Apparently this is just how I build desktop apps now.
And honestly, I really like the split.
Rust gets to handle the native stuff it’s good at, while I can still happily live in TypeScript for the UI.
Sometimes Linux just makes you learn Rust
I’ve also made a couple of smaller Rust utilities mostly because I wanted them for myself.
One was an image format converter.
The other was a screen recording utility.
That one came mostly out of necessity.
I’m using COSMIC on Arch, which means Wayland, which means every once in a while I go looking for a very normal little utility that does exactly what I want and discover that apparently I’ve asked too much of civilization.
Screen recording was one of those cases.
I tried some things. None of them worked quite how I wanted.
Eventually it became:
Fine.
I’ll make one.
And honestly, those little utilities have probably taught me just as much as some of the bigger projects.
They’re small enough that I can actually pay attention to what Rust itself is doing without having fifty other parts of an application fighting for my attention.
There’s something really satisfying about making a tiny tool because you needed it and then just... having the tool.
I even have a pure Rust project
I do technically have one project that’s entirely Rust.
It’s not finished.
It may never be finished.
We don’t need to discuss that part.
I’m sure every developer has at least one project sitting somewhere quietly judging them.
But working on it has still been useful because there’s no TypeScript side to escape to when something gets complicated.
With Tauri, I can naturally divide things between the parts I already understand pretty well and the Rust parts I’m still figuring out.
With a pure Rust project, Rust is the whole damn thing.
There is nowhere to hide.
Which, annoyingly, is pretty good for learning.
Kintara dragged me further into Rust too
Kintara was another project where I ended up using a lot more Rust than I originally expected.
It’s a self-hosted document library I made for PDFs, Markdown, and text files. It watches folders, indexes documents, gives you full-text search and annotations, and has some optional AI features if you want them.
Rust is doing most of the heavy lifting there, along with Axum and SQLite.
That felt pretty different from using Rust as one half of a Tauri app.
I couldn’t just wander back over to the TypeScript side every time Rust started irritating me.
I had to actually stay there and figure things out.
And I think that’s probably around the point where I realized some of the things that originally felt completely bizarre were starting to feel... kind of normal?
Not easy, necessarily.
Just less like Rust was speaking another language while technically being the language I was trying to write.
Progress.
Ownership made sense right up until I actually used it
Ownership and borrowing are obviously the famous Rust hurdle.
And the basic explanation honestly isn’t that difficult.
A value has an owner. You can borrow it. There are rules around mutable and immutable references. Values get dropped when their owner goes out of scope.
Sure.
Got it.
Then you try to build something real.
You passed something into a function, borrowed it somewhere else, stuffed it into a struct, handed it to some async code, and now Rust is informing you that the perfectly good value sitting right there in front of you apparently belongs to someone else.
Cool.
Very helpful.
That’s where the actual learning starts.
I still occasionally solve an ownership problem with clone() because I have other things I would like to accomplish that day.
I’m not above it.
But I’m also starting to notice when I’m moving something that didn’t need to move, when borrowing makes more sense, or when the way I structured the code is actually what made the ownership problem horrible in the first place.
And that feels like real progress.
The compiler went from annoying to genuinely useful
When I first started using Rust, the compiler felt incredibly picky.
You write something.
No.
You fix it.
Still no.
You change something else.
Fantastic. Now you have a completely different error.
But somewhere along the way, I stopped seeing the compiler as this thing constantly blocking me from getting anything done.
Rust’s compiler errors are actually ridiculously helpful.
A lot of the time it tells you exactly what it expected, what it got instead, where everything went wrong, and sometimes even what you should try doing about it.
I’ve probably learned a decent chunk of Rust just from actually reading the compiler errors instead of immediately trying to make the red squiggly lines go away.
And there’s something weirdly satisfying about finally getting a Rust project to compile.
Obviously that doesn’t mean the code is perfect.
But Rust has already forced you to deal with a whole pile of things that another language might happily let you discover later when everything explodes at runtime.
I appreciate that.
Usually.
Cargo is great
Cargo deserves its own little appreciation section because Cargo is great.
Coming from JavaScript, where tooling occasionally feels like someone dumped LEGO from twelve completely different sets onto the floor and told you to build a kitchen, Cargo feels wonderfully cohesive.
Dependencies, builds, tests, formatting, linting, docs, project creation.
It’s just... there.
I use cargo check constantly.
Especially while I’m learning, that quick feedback loop is great.
Change something.
Run cargo check.
See what Rust is mad about now.
Argue with Rust for a minute.
Repeat.
Beautiful.
Rust is changing how I think about code
This is probably the part I didn’t really expect.
I’m obviously getting better at writing Rust, but some of the things Rust forces you to think about have started sneaking into how I write other languages too.
I think more about who should actually own some piece of data.
I think more about whether something really needs to be mutable.
I pay more attention to error states instead of treating them like annoying edge cases I’ll deal with later.
And I notice more often when the structure of the code itself is making something harder than it needs to be.
Even when I’m writing TypeScript, there’s apparently some tiny Rust-shaped part of my brain still hanging around asking questions.
Annoying little bastard.
But useful.
AI has helped a lot, with one big catch
I’ve definitely used AI while learning Rust.
A lot.
It’s fantastic when I have a compiler error that looks like it was delivered from another dimension and I just want somebody to explain what Rust is actually complaining about.
It’s also great for showing me patterns I haven’t seen before or explaining how something would normally be done in idiomatic Rust.
But Rust has also reinforced something I already feel pretty strongly about when it comes to learning with AI.
You still need to understand what it’s giving you.
If an AI changes something to a reference to fix an ownership problem, I want to know why that fixed it.
If Arc<Mutex<T>> suddenly appears in my program, I probably need to understand why we’re sharing ownership and why access needs to be synchronized.
And if every borrow checker complaint somehow gets solved with .clone(), I should probably start asking some follow-up questions.
Rust is complicated enough that blindly accepting generated code catches up with you pretty damn quickly.
But as something I can ask questions, bounce ideas off, and use to help decode what the compiler is yelling at me about?
Absolutely.
It’s been incredibly useful.
I’m still mostly just dabbling
I definitely wouldn’t call myself a Rust expert.
Not even close.
I’m still learning constantly.
There are parts of the language I’ve barely touched, patterns I haven’t fully internalized, and error messages that occasionally make me wonder whether the compiler and I are even discussing the same program.
But Rust doesn’t feel foreign anymore.
And I think that might actually be the bigger milestone.
I didn’t learn it because I decided I needed another language to stick on a skills list.
I just kept finding things I wanted to build where Rust made sense.
A desktop utility?
Yeah, I’m probably reaching for Tauri.
Some little Linux tool I wish existed?
Rust sounds fun.
Something where performance, native integration, or reliability matters?
Rust starts looking pretty tempting.
So I guess that’s how I’ve been learning Rust.
Not by sitting down one day and deciding I was going to become a Rust developer.
Mostly by building things, fighting with the borrow checker, building some more things, getting yelled at by the compiler, and eventually realizing:
Wait.
I actually kind of know Rust now.
Top comments (0)