I Was in Love With Go Before, but Rust Is the Real Deal.

I rewrote all my own projects in Rust. The appeal goes beyond performance: ownership, expressive types, and a compiler that catches more before deployment. The bill arrives in build times, complexity, and disk space.

I wrote a post called “How Come Golang Is So Awesome”, and I meant it.

Fast builds. Straightforward concurrency. A binary I could put on a server without arranging an interpreter and its entire social life first. Coming from shell and Python, Go felt like getting the performance I wanted without signing up for a second job.

I still think Go is excellent.

I also rewrote all my own projects in Rust.

That is a fairly substantial update to the previous recommendation. Rust stopped being the language I admired for specialized work and became the language I actually wanted to build with. The appeal is not just speed. It is how much I can make explicit before the program ever runs.

There are caveats. My disk would like to submit several.

What changed my mind

In the Go post, I put Rust in a specific box: use it when you need control over allocations, tighter performance constraints, or stronger correctness guarantees. For ordinary services and tools, Go was the practical answer.

What changed is that I stopped treating those guarantees as something only a database engine deserves.

A background worker has ownership problems. A web service has state transitions that should not be representable in twelve contradictory combinations. A CLI has resources that need to be released and errors that deserve better than a string and a prayer.

These are ordinary software problems. Rust gives me useful ways to describe them.

Take a job that can be queued, running, finished, or failed. I can represent that with an enum where each state carries exactly the data it needs: a running job has a start time, a finished job has an output, a failed job has an error. Then I can match on those states exhaustively. Add a new variant, and the compiler points out the exhaustive matches that need attention.

Go can model this too. What I prefer is how directly Rust supports it, and how much the compiler participates in keeping the model consistent.

That is the part that won me over: fewer agreements that exist only in my head or in a comment.

The compiler is annoying in a useful way

Rust makes you answer questions Go often lets you defer.

Who owns this value? How long does this reference remain valid? Can this data cross a thread boundary? Are you trying to mutate something while another part of the program still borrows it?

At first, that can feel like paperwork. You know what you meant. Why won’t the compiler just let you do it?

Because “I know what I meant” is not a property it can verify. Ownership and borrowing are.

The ownership model gives Rust memory safety without a tracing garbage collector. Safe Rust also rules out data races, provided the unsafe code underneath its abstractions upholds its contracts. That is a meaningful guarantee, not a promise that the application is correct.

You can still deadlock. You can still leak memory, make a terrible authorization decision, or charge the wrong customer. An unwrap() does not become sensible because the rest of the function is beautifully typed. Tests, review, and production observability still have jobs.

But I like removing classes of mistakes before those other defenses have to catch them. And I like Result, Option, and pattern matching enough that they would matter to me even without a performance argument.

Rust is not pleasant because it accepts everything I write. It is pleasant because some of its refusals are worth having.

Performance matters. Imaginary benchmarks don’t.

I care about efficient software. I run the things I build, so memory and CPU are not someone else’s problem.

Rust gives me control over allocations, data layout, copying, and sharing without requiring a garbage collector. That is attractive for long-running services and tools I want to keep lean.

It does not establish that every Rust rewrite is faster than the Go version.

A service waiting on PostgreSQL can remain a service waiting on PostgreSQL in a different language. An unnecessary allocation is still unnecessary in Rust. So is a bad query. No garbage collector does not mean no runtime overhead, no pauses of any kind, or automatic real-time guarantees.

Go’s collector is good engineering, too. Its own documentation explains the CPU and memory tradeoffs rather than pretending they do not exist. For plenty of workloads, that is a completely reasonable bargain.

My preference is for Rust’s control and guarantees. I am not going to attach a made-up “10x faster” to it to make that preference sound scientific.

Yes, it eats disk space

This is the least romantic part of the relationship.

A lean application at runtime and a large development footprint can both be true. The executable you deploy is not the same thing as the directory your toolchain builds to produce it.

A Rust project’s target/ can hold compiled dependencies, intermediate artifacts, debug information, incremental compilation data, test executables, and separate outputs for different profiles and target platforms. Keep several projects and worktrees around, and you multiply that footprint. Cargo’s downloaded dependencies and installed toolchains take space separately.

Incremental compilation deliberately saves more information to disk so later builds can reuse it. Debug information makes debugging better and artifacts larger. Those are useful things. They are also things you pay for.

This is not just a complaint from my machine. The official 2025 State of Rust survey results, published in March 2026, still identify slow compilation and storage usage as recurring problems among respondents.

There are mitigations, but “just run cargo clean” is an incomplete answer. It removes build artifacts, and then you get to compile them again. Congratulations on moving the cost from your SSD to your afternoon.

A more useful starting point is to decide how much debug information you actually need. The Cargo build-performance guide suggests a setup like this, in the workspace-root Cargo.toml:

[profile.dev]
debug = "line-tables-only"

[profile.dev.package."*"]
debug = false

[profile.debugging]
inherits = "dev"
debug = true

That keeps line information for useful backtraces in your own code, skips dependency debug information in the normal development profile, and provides a fuller debugging build through cargo build --profile debugging.

The tradeoff is explicit: less disk usage and potentially faster builds, but a rebuild when you want the richer debugger experience. Keeping both profiles built also consumes space. Disabling incremental compilation can save additional storage, but may make the edit-build loop worse.

Clean inactive projects when no build is running. Keep useful caches for active ones. Measure before collecting another set of “fast Rust build” flags from the internet.

The answer should not be buying a bigger SSD and pretending the tooling has no problem.

Compilation is the caveat I miss Go over

Go’s fast feedback loop is genuinely good. Rust does not get a pass here because I like the finished result.

Dependency compilation, procedural macros, generic code generation, optimization, and linking all contribute to the work. It is not simply “the borrow checker needs time.” A small source edit can still leave you waiting for a much larger build pipeline.

The Rust team’s 2025 compiler-performance survey found that waiting for incremental rebuilds after small changes was the most common complaint in its open responses. That is the painful version of slow compilation: not a clean build you expected to take a while, but the little interruption repeated throughout the day.

cargo check helps when I need compiler feedback rather than an executable. It does not run the application or its tests. Good caching helps CI. Neither makes compilation free.

I accept this cost. I do not need to rename it a feature.

Async Rust makes you earn it

Goroutines are one of Go’s best ideas from a developer’s point of view. The model is approachable, and the scheduler comes with the language’s standard runtime.

Rust has async and await, but the executor is an ecosystem choice. Tokio is a common one. Then ownership meets suspended work, task lifetimes, shared state, and thread-safety requirements.

The Tokio spawning tutorial explains the Send and 'static requirements on tokio::spawn. They have real reasons behind them: a task can outlive its caller and move between runtime threads. They can also turn an apparently simple change into an education you had not scheduled for that morning.

Blocking work needs care. Cancellation and shutdown need design. Adding Arc<Mutex<_>> everywhere is not an architecture, and adding .clone() until the errors disappear is not necessarily the ownership model you wanted.

This gets easier with experience. It does not become as simple as Go just because an enthusiastic Rust developer tells you to read one more chapter.

The ecosystem is good, not uniformly convenient

Cargo is a major reason Rust works for me. Dependency management, building, testing, and documentation fit together well. Formatting and Clippy add a useful, consistent baseline.

That does not mean every integration is equally mature or equally easy to ship.

Go remains extremely comfortable for infrastructure work. Its standard library and the ecosystem around cloud services, Kubernetes, and networking are serious advantages. Rust has excellent libraries, but a particular vendor SDK or integration can still be the thing that makes your project harder than it needed to be.

And “it builds to a binary” needs the usual footnote. A Rust binary is not automatically fully static. Native dependencies, the target libc, and the machine you build on can matter. Cross-compilation can require more than installing a Rust target. Go has its own caveats once cgo and native libraries enter the picture.

The language choice does not cancel packaging work.

Rewriting my projects is not advice to rewrite yours

I have written against replacing tools just because the replacement is exciting. That argument still applies when the exciting thing is my current favorite language.

I rewrote my own projects. I own that decision and its maintenance cost. That is different from asking a team to discard a working service, relearn its failure modes, and delay useful work because I enjoyed writing an enum.

A rewrite also changes more than the language. You revisit the design, remove old mistakes, and bring everything you learned from the first implementation. Crediting Rust for every improvement would be dishonest.

If Go fits your team, your integrations, and your operational constraints, keep shipping Go. There is no prize for paying a migration bill you did not need.

For my own work, though, Rust has become the default I want to keep investing in. I like the control. I like the type system. I like having the compiler check more of the assumptions that would otherwise depend on me remembering them.

Go made it easy to get something built and running. Rust makes me more explicit about what I am building and what it is allowed to do. That is worth the extra effort to me.

I was in love with Go. Rust is the real deal.

I would still appreciate a smaller target/ directory.