TL;DR — I ran a loop of 100 million iterations in both Go and Rust, which doesn’t do anything great but increment the counter, and here are the results: Go took 365.43175ms while Rust took 83ns, “NANO-SECONDS” 🙂

1 milliseconds = 1000000 nanoseconds (Now do the rest of the math)

Here’s the breakdown 👇🏼

Performance

• Go is designed for fast development, it has quick compilation times over runtime performance. Its efficient garbage collector minimizes pauses, making it suitable for high-scale concurrent applications like web servers and microservices. But, its execution speed is slower than Rust in certain benchmarks it focuses on development speed rather than optimal machine code generation

• Rust is known for its high performance, it allows developers to achieve near-theoretical execution speeds by providing fine-grained control over system resources and memory management. Rust does not use garbage collection, leading to more predictable performance, which is important in applications where execution time is critical

Concurrency

• Concurrency is a core feature of Go. It uses goroutines which are lightweight threads that allow functions to run independently. This simplifies the development of applications that require concurrency and is particularly effective for handling multiple tasks simultaneously without significant resource overhead

• While Rust also supports concurrency through async/await syntax and the Rayon crate for parallel computations, its approach requires more careful management of memory safety. Rust’s strict compiler helps by checking and preventing common concurrency bugs but can make concurrent programming more complex as compared to Go

Memory management

• Go uses automatic garbage collection to manage memory, which simplifies development but can introduce unpredictability in performance due to stop-the-world pauses during the garbage collection process

• Rust has a unique ownership model instead of garbage collection that enforces memory safety at compile time. This leads to fewer runtime errors related to memory management but increases the complexity of the code and the learning curve

Developer experience (Bonus)

• Go is known for its simplicity and readability, Go is often described as “boring,” which makes it accessible for beginners. Its limited feature set reduces the cognitive load on developers, allowing for faster onboarding and easier maintenance of codebases

• Rust offers advanced features such as traits and macros but has a steeper learning curve due to its focus on memory safety and control over system resources. Developers often find themselves needing to think critically about memory management, which can slow down initial development speed

Which one shall I use next, Golang or Rust?

• Go is ideal for developing web APIs, microservices, and highly concurrency applications. Its ease of use and rapid deployment capabilities make it a favorite among teams looking for quick turnaround times

• Rust is best suited for systems programming, performance-critical applications, or scenarios where memory safety is most important. It shines in areas such as game development, operating systems, and applications that require extensive data processing