Rewrite It In Go: Why I Left Rust Behind

Many of you have probably heard of RIIR (Rewrite It In Rust). I don't claim to be great at Rust. I gave it a real try, and my verdict fits in one sentence: "I didn't like it much."

It's not because Rust is weak. Quite the opposite: I'm deeply impressed by its systems programming capabilities and its memory-safety guarantees. It's just that while writing it, I felt like I was solving math problems rather than programming.

Here's what wore me down:

• Fighting the compiler. I'd spend an entire afternoon just convincing it how long a variable should live.
• Async. From picking a runtime to thread-safety, I found it quite tangled. Maybe that's down to the design, maybe I just wasn't used to it yet.
• Slow compiles. Every edit meant another wait.
• Cargo cache. The target directory is a worthy rival to node_modules, and my SSD was the victim.

I once built a simple AI agent in Rust called Crusty. Then I failed at adding new features to it. The codebase was full of .clone() calls just to keep the compiler quiet, and it looked like a pile of garbage. Maybe I was still learning and didn't fully understand Rust back then, but the feeling that "every new feature is a battle" was very real.

RIIG: Rewrite It In Go

I decided to rewrite it in Go. I jokingly named this move RIIG (Rewrite It In Go). The rewrite is Nagare. This wasn't a language switch for fun. I knew exactly what had made me suffer in Crusty, so the rewrite targeted precisely those pain points.

Nagare is an AI assistant that runs directly on the user's machine. It has to do many things at once: call language models, run tools, wait for the user to confirm sensitive actions, and talk to other processes. This is exactly the kind of problem that gave me the biggest headaches in Rust.

Go gave me what I was missing:

• Simple syntax. Go has very few features, so I can still understand my own code weeks later. Some people find it too simple, but for me it's just right. I no longer sit there solving puzzles about which variable outlives which. I write, run, and know right away whether it's right or wrong.
• Goroutines and channels. My project has a lot of asynchronous processes, and this is what helped me the most. Each task runs in its own goroutine, and they talk to each other through channels. The same problem in Rust pushed me into choosing a runtime and then worrying about thread-safety. In Go, I spend my energy on the agent's logic instead of on how threads sit next to each other.
• Time spent on features. I no longer have to think about whether my memory is alive or dead. The edit-build-run loop is also much shorter than waiting for Rust to compile. The most visible result is that I now ship new features steadily, something I couldn't manage in Crusty.

Of course, Go has its price too. I'll get to that below.

But Nagare still has Rust in it, and this is the interesting part. After moving away from Rust, Nagare still uses it in a few places where it's needed. I use Rust exactly where performance and reliability matter. Each component runs as a separate process and talks to the Go side through a protocol I designed myself. Go handles orchestration, because that's the part I change the most. Rust handles the heavy lifting, because it changes rarely and needs to run fast.

The Price Each Side Pays

Everything has two sides:

• Go is fast for writing code, but it has a garbage collector, which is a weakness for projects that need extreme speed.
• Rust drops the GC and checks everything at compile time. The price is things like the lifetimes 'a, 'b, 'static that I once wrestled with.

Takeaways

This isn't a "Go beats Rust" post. What I want to say is: choose technology based on your problem, not on trends. Today anyone can ask an AI to rewrite an app in Rust, post it on GitHub, and collect a few thousand stars. I don't think highly of that recipe, because it skips the harder questions: who will maintain this code? How long does it take to ship a new feature? And your customers don't care what you write it in; they only care whether it does what they need.

Go gave me faster coding and a better developer experience. Rust gave me runtime speed and memory safety. Evaluate carefully before you choose.

If you're curious, try Nagare and tell me where it breaks: https://github.com/smtdfc/nagare.

Happy coding!