Giving Up on Rust: A Post-Mortem

So, that's it then. I'm done with Rust. After five sessions and countless hours of the compiler screaming at me, I've decided to call it. I've even taken down the GitHub repository with my solutions – not out of shame, but because there's no point in keeping evidence of something I'm not continuing.

The Tipping Point

Looking back at my Rustlings sessions, I can see the trajectory clearly. Session 1 was enthusiastic – 2.5 hours of cautious optimism. Session 2 took longer (1.25 hours for three sections) because I was “an idiot with the enums.” Session 3 was quick at 45 minutes, but I was running on fumes and questioning why I was even doing this. Session 4 was two hours of distraction and existential dread about error handling. Session 5 was a brief 30-minute “stretch” after a 26-day break.

And then... nothing. No Session 6. No continuation. Just silence.

The thing is, I didn’t consciously decide to stop. I just... did. The boulder rolled back down the hill, and this time I didn’t push it back up. And honestly? I don’t feel bad about it.

Why I Started (And Why That Wasn’t Enough)

I started Rustlings because Rust is everywhere. Every developer I follow seems to be using it. Every project I’m interested in seems to be built with it. There’s this cultural pressure in tech spaces that if you’re not learning Rust, you’re somehow falling behind.

But here’s the thing: I’m in my fifth year of college overall, third year in IT specifically, and Rust isn’t part of the curriculum. I’m currently three months into this year doing coursework in VB.NET of all things. My actual day-to-day work is in TypeScript and Svelte for frontend, Python for backend and scripting, and lately I’ve been poking at C out of curiosity. I have frontend and backend covered. I do build things.

So why was I torturing myself with the borrow checker at 03:00 when I could barely keep my eyes open?

The Problem Isn’t Rust

I need to be clear about this: Rust isn’t a bad language. It’s clever, it’s powerful, and the compiler genuinely does help you avoid mistakes. The type system is solid. The community is passionate. The tooling is excellent.

The problem is that Rust solves problems I don’t have.

I work primarily in TypeScript and Svelte for web applications. Python for backend services and automation. These tools work for what I build. They’re fast enough, they’re expressive, and I understand them deeply. When I need lower-level control, I’ve been exploring C – and yes, C is arguably “worse” than Rust in many ways, but it’s also simpler. There are fewer concepts to juggle. You write the code, you manage the memory yourself, you move on.

Rust demands that you think about ownership, borrowing, lifetimes – concepts that are undeniably clever and prevent entire classes of bugs. If you want the canonical explanation, the Rust Book’s chapters on ownership and borrowing are the go-to references.

Rust’s safety is brilliant if you need that level of safety. But I don’t. And the cognitive load it imposes isn’t worth it for the kind of work I actually do.

I don't really understand the syntax, even with Rustlings holding my hand.

The Perfectionism Problem

Remember how I mentioned I’ve rebuilt my website ten times? That’s my perfectionism speaking. And Rust is perfectionism incarnate. It demands that you think about every possible edge case, every potential failure, every lifetime and borrow.

For someone who already obsesses over whether their code will make future-me curse present-me, Rust amplifies that anxiety. Every line of Rust code came with the weight that I was doing it wrong, that I was making architectural decisions that would haunt me later, that I was missing some fundamental concept.

In TypeScript, I can write code that works, ship it, and refactor later. The type system helps me catch errors without demanding I solve ownership puzzles. In Python, I can prototype quickly and iterate. Even in C, there’s a directness – allocate memory, free memory, don’t be an idiot about pointers. It’s simple, for better or worse.

Rust’s safety is brilliant if you need that level of safety. But I don’t. And the cognitive load it imposes isn’t worth it for the kind of work I do.

The Exhaustion

By Session 4, I was “very distracted with other stuff” and “restless.” By Session 5, I was coming back after 26 days because I’d been busy turning 20, launching a conversion tool, and preparing to upgrade my Mac mini... which never happened, and current events are saying I really shouldn’t.

The momentum was already gone.

And the thing about momentum is that once you lose it, getting it back requires energy you don’t have. Especially when the thing you’re trying to do feels optional.

What I Actually Need

I don’t need Rust. I need to build things that matter to me using the tools I already understand.

TypeScript and Svelte let me build web applications quickly and with good type safety. Svelte gives me a clean, reactive component model. TypeScript keeps things sane. Python and Bash handle backend work and automation beautifully. And C scratches the itch for lower-level programming without the mental overhead of Rust’s ownership system.

I also want to get back into Godot game development a bit, just to play around with C# and GDScript. Nothing ambitious – maybe a little 2D platformer. Godot makes that easy enough.

Even when I'm going to do that, I might fall behind. Maybe.

Rust doesn’t sound fun right now. It sounds like homework.

The Lesson

There’s this idea in tech culture that you should always be learning, always be growing, always be adding new languages to your repertoire. But that only makes sense if the languages you’re learning actually serve a purpose in your work or your interests.

My web applications don’t need borrow checkers. My Python scripts work fine with garbage collection. When I want to explore systems programming, C gives me what I need without the ceremony.

And honestly? I’d rather get really good at the tools I actually use:

Refine my TypeScript patterns. Master Svelte’s reactivity. Understand Python’s internals better. Actually learn C with intent instead of just poking at it.

So I’m letting Rust go. I’ve taken down the GitHub repository with my Rustlings solutions. Not because I’m ashamed, but because it doesn’t represent a path I’m continuing down. It served its purpose; now it can rest.

And that’s okay. Not every language needs to be in your toolkit. Not every technology needs to be learned.

What’s Next?

Honestly? I don’t know.

Maybe I’ll come back to Rust in five years if I ever need to build something where ownership and borrowing actually matter. Maybe I won’t.

What I do know is that right now, my focus is on TypeScript, Svelte, Python, and exploring C. That’s a solid stack. That’s enough languages to work with. I don’t need to add Rust just because it’s trendy.

Maybe I’ll finally build that Godot game. Maybe I’ll finish some projects instead of starting new ones. Maybe I’ll just stop feeling guilty about not doing every “important” tech thing at once.

The Rustlings exercises are gone from GitHub. They can stay that way. I’ve got other things to build, other projects that excite me, other languages worth my time.