Why Did Discord Ditch Go for Rust? Discover the Performance Revolution!

Imagine facing consistent latency spikes in a crucial service, no matter how finely tuned your code is. That's exactly what Discord faced with their "Read States" service—until they decided to make a game-changing switch.

Why did they move from Go to Rust, and what was the impact? Let's understand.

Performance Challenges with Go

Discord initially used Python, Go, and Elixir for their tech stack, but they encountered issues with one of their critical Go services. Despite its simplicity, this service suffered from slow tail latencies.

Go's garbage collection (GC) process was the culprit: as objects are created and discarded, the garbage collector periodically interrupts the program to clean up memory. This pause in execution causes noticeable spikes in CPU usage and response times, as reflected in their performance graphs.

What did they change?

To address the performance issue, Discord decided to rewrite the service in Rust, and the results were striking.

Rust optimizations included:

• Using a BTreeMap instead of a HashMap to save memory.
• Switching to a metrics library that supports modern Rust concurrency.
• Cutting down on unnecessary memory copies.

Results

• Performance Boost: Rust makes the service over 10 times faster and reduces the worst latency by 100 times compared to Go.
• No GC Spikes: Rust eliminates the garbage collection spikes that caused performance issues in the Go version, resulting in smoother operation.
• Efficiency: Rust’s improved performance means fewer servers are needed, which reduces energy use—a beneficial but secondary outcome.

Rust- The Secret Sauce

Most languages rely on garbage collectors to manage memory automatically, which can introduce performance hiccups. Rust, however, avoids this by using a system of ownership and borrowing.

Here’s how Rust’s approach works:

• Ownership: In Rust, each piece of memory is owned by a single variable, and ownership can be transferred but never shared. This ensures that when a variable goes out of scope, its memory is automatically freed.
• Borrowing: Rust allows functions to borrow data instead of taking ownership. This prevents unnecessary memory copying and maintains efficiency while ensuring data safety. The compiler enforces strict borrowing rules to prevent bugs and data races.
• Affine Types: Rust’s type system, based on affine types, ensures each variable is used at most once. This model helps avoid the performance overhead seen in other garbage collector-free languages.
• Concurrency: Rust’s ownership and borrowing model also enhances concurrency safety, allowing multiple threads to safely access and modify data without the risk of data races.

Rust’s innovations in memory management and concurrency make it both efficient and safe, solving many of the performance and safety issues faced by other languages.

Overall, the shift from Go to Rust at Discord demonstrates the latter's advantages in handling performance-critical tasks and managing memory more efficiently.