https://poltora.dev/rust-vs-go-memory/

While exploring how Rust handles memory, I decided to compare its approach with how Go manages memory.

As a result, I put together a short article: analyzing samples in both Rust and Go, and drawing conclusions about which is faster, more convenient, and more reliable.

The test: https://github.com/curvednebula/perf-tests

So in the test we run 100'000 parallel tasks, in each task 10'000 small structs created, inserted into a map, and after that retrieved from the map by the key.

Go (goroutines):

• finished in 46.32s, one task avg 23.59s, min 0.02s, max 46.32s

• RAM: 1.5Gb - 4Gb

Rust (tokio tasks):

• finished in 67.85s, one task avg 33.237s, min 0.007s, max 67.854s

• RAM: 35Mb - 60Mb

[UPDATE]: After limiting number of goroutines running simultaneously to number of CPU threads, RAM usage decreased from 4Gb to 36Mb. Rust's tokio tasks handle the test gracefully out of the box - no optimization required - only mimalloc to reduce execution time was added.

First, I'm not an expert in those two languages. I'm evaluating them for my project. So my implementation is most likely not the most efficient one. While that's true for both Go and Rust, and I was impressed that Go could finish the task 33% faster. But the RAM usage...

I understand that golang's GC just can't keep up with 100'000 goroutines that keep allocating new structs. This explains huge memory usage compared to Rust.

Since I prefer Go's simplicity - I wanted to make it work. So I created another test in Go (func testWithPool(...)) - where instead of creating new structs every time, I'm using pool. So I return structs back to the pool when a goroutine finishes. Now goroutines could reuse structs from the pool instead of creating new ones. In this case GC doesn't need to do much at all. While this made things even worse and RAM usage went up to the max RAM available.

I'm wondering if Go's implementation could be improved so we could keep RAM usage under control.

-----------------

[UPDATE] After more testing and implementing some ideas from the comments, I came to the following conclusion:

Rust was 30% slower with the default malloc, but almost identical to Go with mimalloc. While the biggest difference was massive RAM usage by Go: 2-4Gb vs Rust only 30-60Mb. But why? Is that simply because GC can't keep up with so many goroutines allocating structs?

Notice that on average Rust finished a task in 0.006s (max in 0.053s), while Go's average task duration was 16s! A massive differrence! If both finished all tasks at roughtly the same time that could only mean that Go is execute thousands of tasks in parallel sharing limited amount of CPU threads available, but Rust is running only couple of them at once. This explains why Rust's average task duration is so short.

Since Go runs so many tasks in paralell it keeps thousands of hash maps filled with thousands of structs in the RAM. GC can't even free this memory because application is still using it. Rust on the other hand only creates couple of hash maps at once.

So to solve the problem I've created a simple utility: CPU workers. It limits number of parallel tasks executed to be not more than the number of CPU threads. With this optimization Go's memory usage dropped to 1000Mb at start and it drops down to 200Mb as test runs. This is at least 4 times better than before. And probably the initial burst is just the result of GC warming up.

[FINAL-UPDATE]: After limiting number of goroutines running simultaneously to number of CPU threads, RAM usage decreased from 4Gb to 36Mb. Rust's tokio tasks handle this test gracefully out of the box - no optimization required - only mimalloc to reduce execution time was added. But Go optimization was very simple, so I wouldn't call it a problem. Overall I'm impressed with Go's performance.

Please don’t say too simple answers like « I prefer it’s libraries » « it’s easier » or « it’s enough for me ».

Rust is regarded as a faster and safer language at the cost of productivity / complexity. Is it just that ?

Do you think Go is more a Java/python replacement or can be optimized as well to run very fast (close to Rust/C) ? Maybe is it as fast in I/O which would be the bottleneck in most scenarios ?

I’m doing my first Go program (for GCP) but I’m interested in Rust as well and I’d like pretty detailed opinions from both sides 🙂

(It can ofc be very well « it’s enough for me » btw, everyone has preferences but then some answers could just be a bit pointless if you see what I mean). I’m sure it’s a « yet another go vs rust » question and I apologize 😆

Has Rust really overtaken Go for high-concurrency backends, or is Go still the go-to for fast, reliable scaling? Would love to see your real-world experiences and what’s driving your team’s language choice these days. Share your thoughts below!

I benchmarked identical Go and Rust servers under heavy load:

- 15,000 concurrent users

- 15 minutes sustained load

- Real Hetzner K3s cluster (not localhost)

- Separate nodes for apps, monitoring, and load testing

- k6 for load generation, Prometheus + Grafana for metrics

Both servers do the same thing: 100 iterations of SHA256 hashing, return JSON.

Go: standard library only

Rust: Hyper + Tokio + sha2

I tracked p50, p90, p95, p99 latencies in real-time.

The results were not what I expected.

Code is on GitHub if you want to run it yourself: https://github.com/huseyinbabal/benchmarks/tree/main/rust-server-vs-goserver

Curious what you all think.