TL;DR: Discord rewrote its Read States service from Go to Rust in 2020 and published detailed benchmarks showing the improvement. That rewrite became one of the most-cited real-world Rust adoption stories in the industry. In 2026, Discord continues to expand Rust usage across its backend infrastructure, serving hundreds of millions of users.
- The rewrite: Read States (tracks which messages you've read in every channel) moved from Go to Rust
- Performance gain: Latency dropped from ~500ms spikes to consistent ~1ms; CPU usage down ~50%
- Root cause: Go's garbage collector caused latency spikes every 2 minutes; Rust has no GC
- Scale: The Read States service handles billions of events per day across 500M+ registered users
- 2026 status: Rust is a standard tool in Discord's infrastructure; not replacing everything, but growing
- Salary: $185K–$350K+ total comp for senior Rust engineers in the US
Who Should Read This?
This article is for engineers considering Rust for high-throughput backend services, and for developers interested in working at Discord. It covers the technical story behind Discord's Go-to-Rust migration, what they learned, and what Rust's role looks like at Discord in 2026.
What Is the Story Behind Discord's Rust Rewrite?
In 2020, Discord published "Why Discord is switching from Go to Rust" — one of the most influential Rust adoption stories in the industry.
The Read States service is one of Discord's most write-heavy systems. It tracks, for every user, which messages in every channel they have read. At Discord's scale — hundreds of millions of users across millions of servers — this service handles an enormous volume of reads and writes continuously.
The service was originally written in Go. Go was a reasonable choice: fast development, good concurrency primitives, and a large ecosystem. But as the service scaled, a specific problem emerged: Go's garbage collector.
Go uses a concurrent mark-and-sweep garbage collector. Every few minutes, the GC would run and cause latency spikes in the service. The latency graph showed a regular sawtooth pattern — every 2 minutes, the service would spike to ~500ms latency before returning to baseline. Discord tried tuning the GC — adjusting GOGC, pre-allocating memory pools, reducing allocations — but the fundamental issue was architectural. The GC always runs at some frequency, and when it does, it pauses program execution.
Rust has no garbage collector. Memory is managed at compile time through the ownership system. There are no GC pauses, no sawtooth pattern, no periodic latency spikes. When Discord rewrote the Read States service in Rust, the memory usage stabilized, and the latency spikes disappeared entirely.
What Were the Performance Results?
The benchmarks Discord published showed dramatic, measurable improvements on every metric that mattered.
The memory profile changed immediately. The Go service had an inconsistent memory footprint that grew and then dropped as the GC collected. The Rust service had a flat, predictable memory profile. Discord noted the Rust service used less memory overall.
CPU usage dropped approximately 50%. The GC in the Go service consumed CPU cycles during collection runs. The Rust service had no equivalent overhead.
Latency improved significantly. The Go service's worst-case latency was in the hundreds of milliseconds during GC pauses. The Rust service achieved consistent sub-millisecond latency for typical operations. The 99th percentile latency improvement was the most impactful for user experience — Discord users stopped experiencing the occasional brief delay when loading a server.
The rewrite took approximately 6 weeks for a small team of engineers who were learning Rust while writing the service. Discord noted that the Rust compiler's error messages and type system caught several bugs that might have been subtle runtime issues in Go.
What Does Discord's Tech Stack Look Like in 2026?
Discord uses multiple languages for different purposes — Rust is one tool in a diverse stack.
Discord's backend runs on a mix of languages:
Elixir handles much of the real-time gateway and presence layer. Elixir (and the underlying Erlang/OTP runtime) is exceptional for maintaining millions of lightweight concurrent connections — ideal for WebSocket gateway infrastructure where each user connection is a separate process.
Python is used for internal tooling, data pipelines, and some backend services. Discord's engineering team has historically used Python for rapid development of non-latency-critical systems.
Rust is used for high-throughput, latency-sensitive services where GC pauses are unacceptable. Read States was the first major Rust service; Discord has continued expanding Rust usage in infrastructure where predictable performance matters.
C++ appears in some lower-level components and in Discord's client applications.
JavaScript/TypeScript powers the web client and Electron-based desktop app.
Discord's choice of Rust is deliberate and targeted: it goes where performance predictability matters most, not as a universal replacement for everything.
What Common Mistakes Do Engineers Make When Evaluating This Rewrite?
The Discord rewrite story is often misread as "Rust is always faster than Go" — that's not what it shows.
The Go service was actually fast at throughput. Go is an excellent language for high-throughput services. The specific problem was GC-caused latency spikes, which is a predictability problem, not a throughput problem. A different service with different memory patterns might have had no GC issues at all.
The lesson is more nuanced: Rust is the right choice when you need predictable low-latency behavior at high load, and when GC pauses (in Go, Java, Python, or any GC language) are creating measurable user-visible problems. For services where occasional 10–100ms pauses are acceptable, Go is often the more productive choice.
Discord did not rewrite everything in Rust. They identified the specific service where Go's GC was causing a real problem, rewrote it in Rust, and validated the improvement. This is the correct approach: measure, identify the bottleneck, fix it precisely.
What Is Discord Hiring for in Rust Roles?
Discord's Rust engineering roles in 2026 focus on infrastructure, reliability, and high-throughput backend services.
Rust roles at Discord typically sit in teams responsible for:
- Infrastructure services: The systems that handle message routing, delivery guarantees, and presence — all performance-critical
- Storage and caching layers: High-throughput data services where memory predictability matters
- Systems tooling: Internal infrastructure tools that require performance and reliability
Discord engineering job listings regularly mention Rust alongside Elixir and Python. The Rust roles tend to require experience with async Rust (Tokio specifically), distributed systems concepts, and — critically — experience debugging production performance issues. Understanding memory profiling, latency analysis, and distributed tracing is expected at senior levels.
Salary at Discord for senior Rust engineers (US, 2026)
Senior Software Engineer (Infrastructure, Rust focus): $180K–$280K base, with total compensation including equity typically $220K–$350K+ depending on level.
Staff/Principal levels with Rust infrastructure ownership: $250K–$400K+ total compensation.
Discord's compensation is competitive with other mid-to-large tech companies in San Francisco and for US remote roles.
How Do You Get a Rust Role at Discord?
Discord looks for engineers who understand distributed systems deeply, with Rust as the implementation language.
The path to a Discord Rust role:
Build async Rust experience. Discord's infrastructure services are async throughout. Tokio is the runtime. You need to understand async/await, the task scheduler, and how to write non-blocking services. Reading the Tokio documentation and building projects with it is required, not optional.
Understand distributed systems fundamentals. Discord's services are distributed across regions. Knowledge of consistency models, failure handling, backpressure, and service-level reliability is expected in technical interviews.
Contribute to or build open-source Rust infrastructure projects. Discord's engineering team publishes open-source work. Contributing to Rust projects that show production-level thinking (error handling, observability, performance benchmarking) demonstrates the right engineering mindset.
Know the GC/no-GC tradeoffs deeply. Discord chose Rust specifically because of the GC problem. Interviewers will probe whether you understand when Rust's memory model matters and when it doesn't.
Want a Structured Path to Discord-Level Rust Proficiency?
Discord's Rust engineering work requires async Rust, distributed systems architecture, and production-grade reliability engineering. Rustify's 9-week bootcamp covers Rust from fundamentals through async programming and systems architecture with 1:1 coaching. Engineers who complete the program are equipped with the foundation needed to build the kind of high-throughput Rust services Discord operates.
Frequently Asked Questions
Discord switched the Read States service from Go to Rust to eliminate garbage collector-caused latency spikes. The Go service experienced ~500ms latency spikes every 2 minutes when the GC ran. Rust has no garbage collector, so the rewritten service maintained consistent sub-millisecond latency at scale.
No. Discord uses multiple languages: Elixir for the real-time gateway, Python for tooling and some backend services, Rust for high-throughput latency-sensitive services, and JavaScript/TypeScript for clients. Rust is one part of a diverse stack, used where predictable performance matters most.
Discord's Rust services are built on Tokio (the async runtime) for concurrent service infrastructure. The specific web frameworks and internal libraries aren't all publicly documented, but Tokio is the confirmed foundation for their Rust async work.
Senior Rust engineers at Discord earn $180K–$280K base salary in the US, with total compensation (base + equity + bonus) typically $220K–$350K+. Staff and principal engineers with Rust infrastructure ownership earn $250K–$400K+ total compensation.
Discord's first significant Rust adoption was the Read States service rewrite published in February 2020. The blog post "Why Discord is switching from Go to Rust" described the process and results. Rust usage at Discord has expanded since then across infrastructure services.
The Discord desktop app is built with Electron (Chromium + Node.js), not Rust. Rust is used in Discord's backend infrastructure services, not the client application. The client is JavaScript/TypeScript in an Electron wrapper.
Yes, particularly for infrastructure and systems roles at companies with high-scale, latency-sensitive services. Companies including Discord, Cloudflare, AWS, and Dropbox have adopted Rust specifically for backend infrastructure where GC latency or memory predictability matters. The demand for Rust backend infrastructure engineers is growing faster than supply in 2026.
Keep Reading
- Rust at FAANG: Amazon, Google, and Microsoft
- How Cloudflare Uses Rust in 2026
- Rust Developer Salary in the USA in 2026
