Hook
After spending several years working primarily with Vue and TypeScript, I started paying closer attention to the tools that power the developer ecosystem.
While exploring modern terminal workflows and developer tooling, I kept encountering the same language again and again: Rust.
Tools like ripgrep (used for fast searching in editors like Neovim), zoxide, exa, terminal applications like lazygit, GPU-accelerated terminals like Alacritty, and TUI frameworks such as Ratatui are all part of the growing Rust ecosystem.
Beyond terminal tools, Rust is also powering projects like the Zed editor, the Biome JavaScript toolchain, and desktop frameworks like Tauri.
Seeing Rust appear across so many modern developer tools made me curious:
What would it be like for a frontend developer to start building tools in Rust?
My Background as a Frontend Developer
My professional work is mostly in the frontend ecosystem. Over the past few years I’ve been working with Vue and TypeScript, building web applications and focusing on the user-facing side of software.
Like many frontend developers, most of my tooling and scripting traditionally lived in the Node.js ecosystem. From build tools to small automation scripts, JavaScript was usually the default choice.
But over time I started becoming more interested in developer tooling itself things like CLI utilities, terminal workflows, and small system-level tools that improve everyday development.
That curiosity is what eventually led me to start exploring Rust.
Why I Decided to Try Rust
My first real reason to try Rust came from experimenting with desktop applications using Tauri.
As someone coming from the frontend world, Tauri felt like a natural bridge. I could still use web technologies for the interface, while Rust handled the system-level parts of the application. That combination made Rust feel much more approachable than jumping straight into systems programming.
After that first step, curiosity started taking over.
I began exploring other areas where Rust is commonly used building CLI tools, experimenting with terminal user interfaces using Ratatui, and generally trying to understand how Rust applications interact more closely with the system.
Several things about Rust were appealing at the same time:
- Memory safety without a garbage collector
- Performance of compiled binaries
- The ability to produce a single standalone executable
- And honestly, the challenge of learning something very different from the JavaScript ecosystem
Rust felt like a language that encouraged thinking differently about how software is structured, especially compared to the object-oriented patterns I was used to from other languages.
What Surprised Me When Learning Rust
Starting with Rust was not as smooth as learning another JavaScript framework or library.
Coming from a background where most of my experience was with object-oriented patterns and higher-level abstractions, Rust initially felt very different. Concepts like ownership, borrowing, and strict compile-time checks were confusing at first.
The shift in thinking was probably the biggest challenge. Instead of relying on runtime behavior or flexible patterns, Rust encourages you to be explicit about how data moves through your program.
At the beginning this can feel frustrating, but something interesting happens over time: the compiler starts to feel less like an obstacle and more like a guide.
Rust’s compiler is extremely strict, but it also provides detailed feedback. Many mistakes that would normally show up as runtime bugs are caught much earlier during compilation.
That experience changes how you think about writing software.
When Rust Makes Sense (and When It Doesn't)
One thing I learned while exploring Rust is that it isn’t meant to replace every tool or language in your workflow.
For example, JavaScript and TypeScript are still excellent choices for building web applications, especially when rapid development and a large ecosystem are important. In frontend development, the productivity and flexibility of the JavaScript ecosystem are hard to beat.
Rust, however, shines in slightly different areas.
Because Rust compiles to a standalone binary and focuses heavily on performance and safety, it works extremely well for things like:
- CLI tools
- terminal applications
- developer tooling
- system-level utilities
- desktop applications with frameworks like Tauri
These kinds of programs often benefit from fast startup times, efficient resource usage, and strong guarantees around memory safety.
For me, Rust didn’t replace the tools I was already using it simply opened a new category of problems that I could explore and build solutions for.
Where My Rust Journey Is Going Next
Learning Rust has changed the way I think about building software.
Even though my primary work is still focused on frontend development with Vue and TypeScript, Rust introduced me to a different layer of the software stack one that is closer to the system and focused on performance, reliability, and tooling.
Right now I’m continuing to experiment with Rust by building small tools, exploring Tauri for desktop applications, and learning more about terminal user interfaces using Ratatui.
For a frontend developer, Rust might feel unfamiliar at first, but that unfamiliarity is exactly what makes the journey interesting.
Stay Rusty 🦀
Top comments (1)
Loved the post! I am currently in the same position I work in Frontend with React and TypeScript but have been suuuuuper curious about Rust. (For me it started with applications such as handy.computer)
Do you have any recommendations on how to start to learn Rust? Or maybe some Books or channels recommendations?