How to find Rust developers in 2026: A sourcing guide

Discord migrated their Read States service from Go to Rust to handle 11 million concurrent users and saw tail latencies drop from 30 milliseconds to under 1 millisecond. Cloudflare built Pingora, their HTTP proxy handling over 1 trillion requests per day, in Rust — replacing Nginx. Google has 1.5 million lines of Rust in Android. Microsoft has 188,000 lines in the Windows kernel. AWS built Firecracker, the microVM monitor behind Lambda and Fargate, entirely in Rust. None of this is experimental. The companies that handle the most traffic and the most sensitive workloads on earth chose Rust for production infrastructure.

Like Go and Elixir, Rust's ecosystem is almost entirely open source and lives on GitHub. The compiler, the async runtime, the web frameworks, the game engines, the database engines — all developed in the open. That makes GitHub the single best sourcing channel for Rust talent. We covered Rust briefly in our niche language sourcing guide. This is the deep dive.

This guide covers where Rust developers work on GitHub, what separates experienced systems engineers from developers who fought the borrow checker and gave up, why the ownership model matters more than syntax knowledge, and how to build a sourcing workflow that actually works.

The Rust developer market in 2026

Rust's developer population has grown rapidly. Estimates from SlashData and corrode.dev place the global community at roughly 3.7 to 4 million developers, with approximately 700,000 to 1 million using Rust as their primary language. About 26% use it professionally. Those numbers sound large until you compare them to Go's 4 to 5 million, Python's 16 million-plus, or JavaScript's 20 million-plus. And the number that matters for hiring is not total developers but the subset with production experience in your specific domain, which is much smaller.

Enterprise adoption has accelerated. Roughly 45% of organizations now run Rust in production workloads, up from single digits five years ago. The Rust Foundation's membership includes Google, Microsoft, AWS, Meta, Huawei, and dozens of other companies funding engineering work on the language. Linux 6.1 introduced initial Rust support in the kernel. Android, Windows, ChromeOS, and Fuchsia all have significant Rust codebases. Production demand is pulling Rust in faster than the talent supply can grow.

Compensation reflects this imbalance. US senior Rust developers earn $150,000 to $280,000 per year. Staff and principal engineers with deep Rust expertise can reach $220,000 to $320,000 or higher. Rust roles carry a 15.5% salary premium over comparable positions in other systems languages. Blockchain and fintech pay the most: $155,000 to $320,000. Solana, Sui, Aptos, and other Layer 1 chains are built on Rust and compete aggressively for the same talent pool. Infrastructure companies (AWS, Cloudflare, Fastly, Fly.io) and database vendors (TiKV, SurrealDB, Neon) also pay at the top of the market.

Hiring cycles run 60 to 90 days using traditional sourcing. Companies that accept adjacent backgrounds (C++ developers with Rust side projects, Go developers transitioning, Haskell or OCaml engineers who already think in algebraic types) can cut that to 35 to 50 days. The central problem in Rust hiring is circular: companies want senior Rust experience that barely exists, while developers eager to write Rust professionally cannot get hired because they lack production experience. Corrode.dev, a Rust consulting firm, advises companies to stop requiring production Rust experience for application-level roles and instead test for systems thinking and learning velocity.

Where do Rust engineers concentrate? Systems infrastructure (networking, proxies, runtimes, operating systems), cloud and serverless (microVMs, container runtimes, orchestration), databases and storage engines, blockchain and distributed systems, game engines, CLI and developer tooling, WebAssembly, embedded systems, and ML inference. The common denominator: performance-critical software where memory safety is non-negotiable and garbage collection pauses are not acceptable.

Where Rust developers contribute on GitHub

Rust's open source ecosystem is large and active. Because the language is systems-oriented, contributions tend to be substantive. You do not casually send a pull request to an async runtime or a database engine. GitHub is one of the most effective sourcing channels for Rust engineers because the projects they contribute to are the same ones running in production at scale.

The language itself. rust-lang/rust (111,600 stars) is the compiler, standard library, and toolchain. Contributors here work on type checking, code generation via LLVM, the standard library's data structures and traits, and the toolchain that ships with rustup. It is one of the most active repositories on GitHub. Even issue triage and RFC discussion participation signals someone who understands Rust at a deep level. The bar for merged contributions is high. Anyone with multiple accepted PRs to the compiler is worth reaching out to immediately.

The async runtime. tokio-rs/tokio is the async runtime that most production Rust services depend on. It provides the event loop, task scheduling, timers, and I/O primitives that async Rust is built on. Contributors to Tokio understand concurrency well beyond "I used async/await." They understand work-stealing schedulers, pinning, waker mechanics, and cancellation safety. If someone has merged code into Tokio, they are a strong systems engineer.

Web frameworks. tokio-rs/axum is a web framework built on Tokio that has been growing rapidly. It uses Rust's type system for request extraction, middleware composition, and error handling in ways that are idiomatic and zero-cost. Axum has largely overtaken Actix-web and Rocket for new Rust web services. Contributors understand both web architecture and Rust's trait system at a practical level.

CLI tooling. BurntSushi/ripgrep (61,800 stars) is a line-oriented search tool that is faster than grep, ag, and ack. Andrew Gallant (BurntSushi) wrote it, and the codebase is widely studied as one of the best examples of well-written Rust. The error handling, performance optimization, and cross-platform support are all worth reading. Contributors to ripgrep or its underlying regex engine crate write the kind of code other Rust developers learn from.

Game engines. bevyengine/bevy (45,400 stars) is a data-driven game engine built on an Entity Component System (ECS) architecture. It is one of the most active Rust projects on GitHub. Contributors work on rendering pipelines, audio systems, asset loading, physics, and the ECS framework itself. Bevy attracts developers who combine systems programming with real-time graphics knowledge, which is not a common overlap.

Distributed databases. tikv/tikv (31,400 stars) is a distributed transactional key-value database built by PingCAP. It is the storage layer for TiDB, a distributed SQL database. Contributors work on Raft consensus, transaction processing, storage engines, and distributed systems coordination. A TiKV contributor is almost certainly a senior distributed systems engineer.

Browser engines. servo/servo is a web browser engine originally developed at Mozilla Research. Servo drove many of Rust's language features: ownership, borrowing, and lifetimes were shaped by the needs of parallel CSS layout and DOM processing. Contributors understand browser internals, parallel computing, and the real-world constraints that influenced Rust's design. Servo's development has been intermittent, but its contributor alumni include some of the strongest Rust engineers working today.

Desktop applications. tauri-apps/tauri is a framework for building desktop applications using web technologies for the frontend and Rust for the backend. Tauri apps are typically 10 to 100 times smaller than their Electron equivalents. Contributors understand cross-platform desktop development, IPC (inter-process communication), system APIs, and security sandboxing.

Databases. SurrealDB/surrealdb is a multi-model database (document, graph, relational) written in Rust. Contributors work on query parsing, storage engines, indexing, and the intersection of multiple data models. Database engine contributors in any language tend to be strong engineers. The domain demands it.

Machine learning. huggingface/candle is a machine learning framework written in Rust by Hugging Face. It provides tensor operations, model inference, and GPU acceleration without Python's overhead. Contributors understand both model architectures and low-level performance optimization. As ML inference moves to the edge and into latency-sensitive environments, engineers who can write Rust ML code are getting harder to hire.

Quality signals in Rust code

Rust's compiler enforces correctness that other languages do not. The borrow checker, ownership model, and type system mean that code that compiles is already free of entire categories of bugs: data races, use-after-free, null pointer dereferences. But compiling is not the same as being well-written. Seniority signals on GitHub apply broadly, but Rust has its own markers of expertise.

Ownership and borrowing. This is the most telling signal. Every Rust developer must contend with the borrow checker, but how they do it separates beginners from experts. A beginner fights the borrow checker: cloning data unnecessarily, wrapping everything in Rc<RefCell<T>>, restructuring code to avoid lifetime annotations. An experienced developer designs around it. They structure data ownership so that borrows are natural, use iterators and closures to avoid intermediate allocations, and let the ownership model guide the architecture instead of fighting it. If you see a codebase littered with .clone() calls, the developer is still learning. If the data flows cleanly through owned and borrowed references with minimal cloning, they understand Rust.

Zero unsafe in application code. Rust's unsafe keyword bypasses the compiler's safety guarantees. Experienced Rust developers rarely need it outside of FFI (calling C libraries), performance-critical hot paths where the compiler cannot prove safety, or low-level system interactions. If you see unsafe scattered throughout application-level code (a web service, a CLI tool, a data pipeline), that is a red flag. The developer is either reaching for unsafe to work around problems they do not understand, or they are writing C in Rust syntax. Good Rust application code has zero unsafe blocks. When unsafe is genuinely needed (library code, FFI wrappers, custom data structures), it should be isolated, minimal, well-documented, and wrapped in a safe API.

Error handling. Rust has no exceptions. Errors are values, handled through the Result<T, E> type. How a developer handles errors tells you a lot. The split between thiserror and anyhow is telling: thiserror is for library code where callers need typed, matchable error variants. anyhow is for application code where ergonomic error reporting matters more than structured handling. A developer who uses thiserror in a library and anyhow in an application understands the ecosystem conventions. A developer who uses .unwrap() everywhere is either prototyping or does not understand error propagation.

Trait design. Traits are Rust's mechanism for abstraction — similar to interfaces but more powerful. Well-designed trait hierarchies, blanket implementations (implementing a trait for all types that satisfy certain bounds), and the choice between associated types and generic parameters all reveal experience level. A developer who writes impl<T: Display> ToString for T understands how Rust's trait system enables zero-cost polymorphism. A developer who writes concrete types everywhere and duplicates code across similar structures does not yet think in traits.

Lifetime annotations. Lifetimes are Rust's way of tracking how long references are valid. They are the part of Rust that intimidates newcomers most. An experienced developer uses explicit lifetime annotations correctly and sparingly. Rust's lifetime elision rules handle most cases automatically, so explicit annotations should only appear when the compiler cannot infer the relationship. A developer who sprinkles 'a annotations on every reference is over-annotating. A developer who avoids references entirely to dodge lifetimes (cloning or using String instead of &str) is under-utilizing the language.

Async patterns. Async Rust is notoriously difficult. Proper use of the Tokio runtime, understanding of pinning (why Pin<Box<dyn Future>> exists), stream processing, and cancellation safety are all advanced topics. A developer who writes async code that correctly handles task cancellation, uses tokio::select! without introducing subtle bugs, and knows when to use Send + Sync bounds versus !Send futures has internalized concepts that take months to learn. Async Rust is where the gap between "I wrote some Rust" and "I build production Rust services" shows up most clearly.

Macro usage. Rust has two kinds of macros: declarative macros (macro_rules!) and procedural macros (derive macros, attribute macros, function-like macros). Both can reduce boilerplate dramatically. An experienced developer uses macros to eliminate repetitive patterns without sacrificing readability. The macro's expansion should be predictable and debuggable. Procedural macros that generate trait implementations, builder patterns, or serialization code are common in well-designed Rust libraries. But macro overuse (using macros where a function or trait would suffice) is a negative signal. Good Rust developers reach for macros as a last resort, not a first instinct.

Rust and the systems programming ecosystem

Understanding where Rust fits among systems languages helps you source and evaluate candidates more effectively. Rust compiles to native code via LLVM, the same compiler backend used by Clang (C/C++), Swift, and Zig. This means Rust produces binaries with comparable performance to C and C++ — there is no runtime, no garbage collector, and no interpreter overhead. The "zero-cost abstractions" principle means that higher-level constructs (iterators, closures, traits) compile down to the same machine code you would write by hand in C.

Cargo and crates.io are the package manager and registry. Cargo handles dependency resolution, building, testing, documentation generation, and publishing. Crates.io hosts over 248,000 packages. The tooling is frequently cited as a primary reason developers enjoy writing Rust. The language has a steep learning curve, but the build system and package management are best-in-class. When evaluating a candidate, their crate publishing history on crates.io is as useful as their GitHub profile.

The edition system (2015, 2018, 2021, 2024) allows Rust to evolve its syntax and semantics without breaking existing code. Each edition can introduce new keywords, change default behaviors, and modernize the language while maintaining backward compatibility. Code from different editions can interoperate within the same project. A developer who writes idiomatic 2021 or 2024 edition Rust is keeping current with how the language is evolving.

The RFC process governs how Rust evolves. Major language changes go through a public Request for Comments process where anyone can participate. Developers who author or substantively contribute to RFCs are shaping the direction of the language. Most recruiters miss this signal. RFC participation does not show up on a GitHub contribution graph, but it indicates deep expertise and community standing.

Why do companies choose Rust over the alternatives? Over C++, Rust provides memory safety without a garbage collector. The ownership model eliminates data races, use-after-free, and buffer overflows at compile time: bugs that cost C++ teams weeks of debugging and security patching. Over Go, Rust has zero-cost abstractions and no garbage collection pauses, which matters for game engines, trading platforms, and real-time audio. Over C, Rust has modern tooling (Cargo, crates.io, rustfmt, clippy), a richer type system, and the same performance characteristics. The tradeoff is a steeper learning curve and longer compilation times, which is why Rust adoption concentrates in domains where correctness and performance justify the investment.

WebAssembly is worth paying attention to. Rust is one of the best-supported languages for compiling to WASM, and projects like wasm-bindgen, wasm-pack, and leptos (a full-stack Rust web framework) are growing fast. Figma's performance-critical rendering engine runs Rust compiled to WASM in the browser. Cloudflare Workers supports Rust via WASM. Developers with Rust-to-WASM experience bridge systems programming and web development, and there are not many of them.

Embedded is another area to watch. Rust's no_std mode strips the standard library down to the core language, enabling Rust to run on microcontrollers and bare-metal environments. The embedded-hal ecosystem provides hardware abstraction layers for dozens of chip families. Embassy provides an async runtime for embedded systems. With Linux kernel support for Rust modules landing in 6.1, Rust has become a viable language for kernel development, a domain that was exclusively C for 30 years.

How to search for Rust developers on GitHub

GitHub search is a starting point, but Rust's ecosystem has properties that enable sourcing strategies not available for most languages.

Language filter. Filtering by language:rust in repository or code search surfaces developers who actively write Rust. Unlike niche languages where the filter produces a small, high-quality list, Rust's community is large enough that you will get a bigger set that needs additional filtering. Focus on repositories with meaningful star counts, recent activity, and non-trivial codebases. Personal projects with a few hundred lines of Rust are less informative than sustained contributions to production-grade libraries.

Crates.io cross-referencing. Crates.io is Rust's package registry and one of the most underused sourcing channels for Rust talent. Over 248,000 crates maintained by roughly 61,000 unique owners. That is a pool of developers who have not only written Rust but published reusable, documented, versioned packages for others to depend on. Crate owners are listed publicly. Cross-reference high-download crates with their maintainers' GitHub profiles. A developer whose crate has thousands of weekly downloads is maintaining infrastructure that other Rust developers depend on. They are almost certainly senior.

Community sources. The Rust community is active across multiple channels. Reddit's r/rust has roughly 350,000 members. The Rust Discord server has about 68,000. This Week in Rust is a weekly newsletter that highlights notable contributions, crate releases, and community activity. Its archives are a searchable list of developers doing noteworthy work. The Rustacean Station podcast features interviews with Rust developers and project maintainers. RustConf speaker lists, Rust meetup organizers, and Rust working group members are all publicly traceable.

Contribution recency calibration. Rust's community is large enough that you can apply stricter recency filters than for niche languages like Elixir. Focus on contributions within the last 3 to 6 months. But Rust developers often work on long-lived projects with infrequent but substantial commits. A database engine contributor might push once a month with a large, carefully reviewed changeset. Do not mistake low commit frequency for inactivity. Look at the substance and size of contributions, not just the count.

Adjacent language signals. Many strong Rust developers come from other systems programming backgrounds. C++ developers are the most common pipeline. They already understand memory management, pointer semantics, and systems-level thinking, and typically ramp to productive Rust in 2 to 4 weeks. Haskell and OCaml developers, familiar with algebraic data types, pattern matching, and type-driven development, ramp in 1 to 3 weeks. Go developers bring concurrency experience but need time to internalize ownership and the borrow checker (3 to 6 weeks). Python and TypeScript developers are a longer ramp at 4 to 8 weeks but can be effective for application-level Rust (web services, CLIs, WASM) relatively quickly. Search for developers whose primary language is C++, Go, or Haskell but who have Rust repositories or contributions. They may be further along the transition than their profile suggests.

A practical Rust sourcing workflow

Here is what works, from initial discovery to first outreach.

Step 1: Define the technical profile. "Rust developer" covers a wide range. Are you hiring for systems infrastructure (networking, proxies, runtimes)? Web services (Axum, Actix, API development)? Embedded systems (no_std, microcontrollers, firmware)? Game development (Bevy, real-time graphics, ECS)? WebAssembly (browser-based compute, edge functions)? Blockchain (smart contracts, consensus protocols)? Database internals (storage engines, query processing)? Each maps to different GitHub repositories, different crates, and different contributor communities. A Bevy game engine contributor has a very different skill set than a TiKV distributed database contributor, even though both write excellent Rust.

Step 2: Identify target repositories. Based on the technical profile, list the GitHub repositories and crates.io packages where your ideal candidate would contribute. For async services: Tokio, Axum, Hyper, Tower. For systems infrastructure: rust-lang/rust, Firecracker, Pingora. For databases: TiKV, SurrealDB, Neon. For game dev: Bevy and its ecosystem crates. For CLI tools: ripgrep, fd, bat, delta. For WASM: wasm-bindgen, Leptos, Yew. For embedded: embassy, embedded-hal, probe-rs. Map the role to the repos.

Step 3: Extract contributors. Use GitHub's contributor graphs, the GitHub Events API, or tools like riem.ai that index GitHub event data at scale. Focus on recent contributors (last 3 to 6 months) with meaningful contributions: code changes, code reviews, design discussions, RFC participation. Distinguish between drive-by typo fixes and sustained engineering work. In Rust's ecosystem, code review participation is a particularly strong signal. Reviewing someone else's unsafe code or async implementation requires real expertise.

Step 4: Evaluate profiles. Review each candidate's GitHub profile for the quality signals above: ownership patterns, unsafe usage, error handling choices, trait design, lifetime usage, async patterns, macro design. Seniority signals like code review participation and cross-project contributions matter. Check whether they maintain published crates on crates.io. Look at their commit messages. Rust's culture values clear, detailed commit messages and PR descriptions. A developer who writes "fix bug" versus one who writes "fix unsoundness in Pin projection for self-referential structs" is telling you everything about their level.

Step 5: Expand to adjacent backgrounds. Do not limit sourcing to developers with "Rust" as their primary GitHub language. C++ developers with Rust side projects are the most natural pipeline. They already think about memory and performance at the right level. Go developers who have outgrown garbage collection constraints are moving to Rust in growing numbers. Haskell and OCaml developers bring type system sophistication that transfers directly to Rust's generics and traits. Check GitHub for Rust repos from developers whose primary language is C++, Go, or Haskell. A C++ developer with six months of active Rust contributions may be a better hire than someone with two years of Rust experience who never internalized ownership.

Step 6: Craft personalized outreach. Generic messages get ignored. Effective developer outreach references specific contributions: "I noticed your work on the cancellation safety improvements in Tokio's select! macro. We are building a distributed task scheduler on Tokio and your understanding of async cancellation is exactly what we need." Rust developers receive frequent recruiter outreach. The messages that get responses show genuine technical understanding. Mention the specific crate, the specific PR, or the specific design decision that caught your attention. Do not say "I see you are a Rust developer." Say what you saw in their code.

Step 7: Scale with tooling. The manual workflow above works but takes time. Tools like riem.ai automate the discovery and evaluation steps by analyzing 30 million-plus GitHub events per month and surfacing Rust developers based on actual contribution patterns. Instead of manually browsing contributor graphs and cross-referencing crates.io, you describe the technical profile in natural language ("Rust developers who contribute to async runtimes and have experience with Tokio, distributed systems, or database internals") and get a ranked list of candidates with contribution summaries and quality scores.

Frequently asked questions

How many Rust developers are there?

Roughly 3.7 to 4 million Rust developers globally as of 2026, based on estimates from SlashData and corrode.dev. Of those, approximately 700,000 to 1 million use Rust as their primary language, and 26% use it professionally. Rust is the most-admired programming language in the Stack Overflow Developer Survey for the ninth consecutive year. Adoption has roughly doubled every two years since 2020, but experienced production engineers remain scarce relative to demand, especially for systems-level work involving unsafe code, FFI, or no_std embedded programming.

What salary should I expect to pay Rust developers?

In the US, senior Rust developers earn $150,000 to $280,000 per year. Staff and principal engineers with deep Rust expertise can reach $220,000 to $320,000 or higher. Rust roles carry a 15.5% salary premium over comparable positions in other systems languages. Blockchain and fintech pay the most, with ranges from $155,000 to $320,000. Solana, Sui, Aptos, and other Layer 1 chains are built on Rust and compete aggressively for talent. Infrastructure companies (AWS, Cloudflare, Fastly) and database vendors also pay at the top of the range. The premium reflects genuine scarcity: companies need senior Rust experience that barely exists in the market.

Should I require Rust experience or hire developers who can learn it?

It depends on the role. For systems-level work involving unsafe code, FFI bindings, no_std embedded programming, or performance-critical hot paths, prior Rust production experience matters. These areas require deep understanding of the ownership model, memory layout, and the borrow checker that cannot be learned quickly. For application-level work (web services with Axum, CLI tools, WASM applications), strong developers from adjacent backgrounds can ramp effectively. C++ developers typically ramp in 2 to 4 weeks. Haskell and OCaml developers, already familiar with algebraic types and pattern matching, ramp in 1 to 3 weeks. Python and TypeScript developers take 4 to 8 weeks. Corrode.dev's advice: do not require production Rust experience for application-level roles. Test for systems thinking, learning velocity, and the ability to reason about ownership.

What Rust projects and frameworks should I look for on GitHub?

For async runtime and networking: tokio-rs/tokio and tokio-rs/axum. For the language and toolchain: rust-lang/rust. For CLI tools: BurntSushi/ripgrep. For game development: bevyengine/bevy. For distributed databases: tikv/tikv. For browser engines: servo/servo. For desktop applications: tauri-apps/tauri. For databases: SurrealDB/surrealdb. For machine learning: huggingface/candle. Beyond specific repos, crates.io package authors with well-maintained, widely-used crates are strong candidates. The registry has over 248,000 crates maintained by roughly 61,000 owners, making it a useful sourcing pool of developers who build infrastructure others depend on.

Do Rust developers need to know C or C++?

Not necessarily, but it helps for systems-level work. Rust's FFI interoperates with C, and many Rust projects wrap or replace C and C++ libraries. Developers working on unsafe code, kernel modules, or embedded systems benefit from understanding memory layout, pointer arithmetic, and calling conventions that C and C++ developers already know. Many Rust developers come from C++ backgrounds, and the mental model transfers well. Ownership in Rust formalizes patterns that experienced C++ developers already follow informally with RAII and smart pointers. For web services, CLI tools, WASM applications, and application-level Rust, no C or C++ knowledge is required. Many successful Rust developers come from Python, TypeScript, Haskell, or Go backgrounds.

How long does it take to hire a Rust developer?

Average time-to-fill for Rust roles is 60 to 90 days using traditional sourcing methods. Companies that accept adjacent backgrounds (C++ developers with Rust side projects, Go developers transitioning, Haskell or OCaml engineers with demonstrated Rust learning) can reduce this to 35 to 50 days. The main bottleneck is the mismatch between demand for senior Rust experience and its actual availability. Companies routinely require 3 or more years of production Rust experience in a language where most practitioners have been writing it for less than 2 years. RustConf 2026 is September 8 to 11 in Montreal and is a good in-person sourcing opportunity. Sourcing from GitHub contribution data and crates.io package ownership can shorten timelines by identifying candidates who are actively building but not on job boards.