Before Rust, I built programs in Python, JavaScript (with TS), Java, Clojure, Elixir, and C++ (both large- and small-scale applications — some as personal projects, others deployed to production or used in large-scale government operations).

Since the beginning of 2025, I decided to work on a new project — a desktop application. I went all in with Electron + React. But since this desktop app requires some Python libraries, I also had to build (and package) a Python runtime that would start a Flask server and let me run the required tasks inside my Electron app.

However, I started hitting some problems with this stack: I had to manage the lifecycle of the Python server, handle available ports on localhost, and write a bunch of scripts (still far from done and quite error-prone) for each target OS. Not to mention the bundle size — if Electron by itself is already bloated, packaging a Python runtime makes everything worse. And I hadn’t even gotten to the auto-updater functionality yet (the Python runtime would probably make that even harder).

With that in mind, it became clear to me that I had to give Rust (or Tauri, for that matter) a try, because Rust is perfectly capable of running the tasks I need on the user’s machine — and it offers production-ready libraries to do so.

It took me probably a few days (like 3 or 4) to go through The Rust Book (amazing read), and another 5 or 6 to spin up my Tauri app and please the compiler after adding my initial backend logic. I’m still learning, but here’s what I noticed:

I’m writing my code myself. I use Claude only as a mentor for good practices. I also use it to discover existing crates that might solve my problems and to understand how to use their APIs. 1.

Pleasing the compiler is hard, but more on that later. 1.

I’m writing more code (to achieve the same functionality) compared to Python, and it’s also taking longer. I’m sure I’ll speed up once I get a good grasp of the API and of Rust’s way of thinking. 1.

Build times on my computer are long. I had to disable linking/debugging for imported crates to speed it up (went from 1+ minute to about 6 seconds of compile time). 1.

I love that I can write functional code and only rely on traits/impl when I need to. My first approach to Rust was very OOP-oriented (like in Java), where I tried to force everything into dyn boxes, impl, and traits. Then I realized I could just use functional programming (like in Elixir or Clojure), and things became easier. 1.

What amazed me: when my program compiles, it just works. But first we need to please the compiler, which is actually hard (for a first comer like me). The fact that Rust negates null values (enforcing Option handling) is both a blessing and a curse lol. The thing is that, once compile, my program runs smoothly even after multiple changes (not necessarily correct ones). I was used to running the program and reading the stack trace after every change. Now I find myself waiting for the stack trace to appear — but it rarely does. 1.

I also feel that I now have much more granular control over my backend compared to Python (for whatever reason). Maybe that’s because I relied more on Python libraries before, and now I have to make more decisions myself. But overall, I just feel more capable of doing things with my app than before.