От «Hello, World» до коммита в rustc: Roadmap Rust-разработчика на 2026 год

Rust давно перестал быть языком энтузиастов. На нём собраны куски ядра Linux, движки баз данных и аналитики (TiKV, Materialize, Polars), бэкенды Cloudflare и Discord. Под Rust пишут прошивки для ESP32 и STM32, фронтенд через WebAssembly, инференс LLM.

Microsoft переписывает части Windows, AWS строит на Rust Firecracker и Bottlerocket, Google пускает его в Android и в дерево ядра. По зарплатам Rust пятый год держится в верхнем дециле Stack Overflow Survey, и семь лет подряд — самый любимый язык разработчиков.

Я веду github.com/Develp10/rust-roadmap-ru — живую карту того, что и в каком порядке учить. Эта статья — её расширенный текстовый вариант с примерами, ссылками и личным опытом.

Что внутри

• Карта по уровням и когда брать Rust

• Быстрый старт на первый месяц

• 12 этапов roadmap’а от настройки окружения до уровня профи

• Частые ошибки новичков и слабые места Rust

• До коммита в rustc: путь до контрибьютора компилятора

• Crate-замены привычных инструментов для тех, кто переходит с Python/Node/Go

• Деньги, будни разработчика и как искать первую работу

• Анти-FAQ, интервью, книги и сообщество

• Чек-лист проектов и куда идти прямо сейчас

Карта по уровням

Цифры справа — медиана по моим знакомым и опросам в чатах, не гарантия. Кто-то с сильным C+±бэкграундом проходит путь до Middle за 8 месяцев, кто-то застревает на ownership на год — и это нормально.

Как пользоваться этой картой

Три правила:

• Не торопись. Этапы 2, 7 и 9 — переломные. Без них следующие просто не лягут.

• Перепрыгивать можно, но возвращаться придётся. Если читал про async раньше, чем разобрался с ownership — почти наверняка вернёшься назад. Это бесплатный совет, который я выучил дорогой ценой.

• Контрольные точки честные. Если не можешь объяснить пример из контрольной — этап не пройден, как бы ни хотелось двигаться дальше.

Что Rust решает

Один пример вместо лекции. Вот фрагмент на C++:

std::vector<int> v = {1, 2, 3};int& r = v[0];v.push_back(4);   // вектор может перевыделить памятьstd::cout << r;   // r теперь висячая ссылка, UB

То же самое на Rust компилятор остановит ещё до запуска:

let mut v = vec![1, 2, 3];let r = &v[0];v.push(4);        // ошибка: cannot borrow `v` as mutable because it is also borrowed as immutableprintln!("{}", r);

Это и есть продажа Rust в одном слайде: целый класс багов, на которые в C/C++ уходят дни отладки и которые регулярно становятся CVE, в Rust превращается в ошибку компиляции. Не «безопасный язык вообще», а конкретно отсутствие data races и use-after-free без GC.

Borrow checker не учит писать Rust. Он учит думать о владении данными, и эта привычка остаётся в любом языке, который ты возьмёшь потом.

Второй уровень — производительность. Zero-cost abstractions значат, что итераторы, traits и async компилируются в такой же машинный код, как ручной цикл на C. Третий — экономика. Серверная аренда дорогая, энергопотребление считают, и компании мигрируют горячие пути с Python и Java на Rust ради уменьшения парка машин в разы.

Это не теория: Discord переписал Read States с Go на Rust и убрал пики GC, Cloudflare на Rust пишет Pingora — прокси, через который идёт значительная часть мирового HTTP-трафика. Это другой класс надёжности.

Когда брать Rust, а когда нет

Самое честное, что можно сказать новичку: Rust — не лучший выбор для большинства задач. Он лучший для задач, где цена ошибки высока, а ресурсы ограничены.

Если в твоём случае Rust «можно, но не обязательно» — бери то, что знает команда. Rust окупается на горизонте полугода и больше.

Быстрый старт: первый месяц

Не пытайся прочитать The Rust Book целиком и параллельно Rustlings и параллельно курсы. Это рецепт выгорания. Лучше так:

• неделя 1: главы 1-6 The Rust Book + первые 30 упражнений Rustlings;

• неделя 2: главы 7-10 + написать CLI-утилиту на 200 строк (грабер RSS или подсчёт строк в директории);

• неделя 3: главы 11-13 + переписать одну свою старую утилиту с Python/Go на Rust и сравнить;

• неделя 4: главы 14-17 + начать первый «настоящий» проект (см. чек-лист в конце).

К концу месяца у тебя в портфолио должен быть один проект, на который не стыдно дать ссылку. Без своего проекта Rust в голове не закрепляется, и туториалы создают ложное чувство уверенности.

Часть 1. Roadmap по этапам

Этапы 0-2 — фундамент языка. Этапы 3-6 — язык в production. Этапы 7-9 — глубина. Этапы 10-11 — выход в индустрию.

Этап 0. Настройка окружения — фундамент, без которого всё сыпется

Что ставим

• rustup — менеджер тулчейнов. Никогда не ставь rustc через системный пакетный менеджер;

• VS Code + rust-analyzer или RustRover от JetBrains. rust-analyzer бесплатный и почти не уступает;

• cargo-edit, cargo-watch, bacon для удобной разработки;

• nightly-канал для экспериментов: rustup toolchain install nightly.

Минимальный шаблон проекта

Создай и сохрани себе .cargo/config.toml с быстрым линкером и шаблон Cargo.toml с твоими привычными зависимостями:

# .cargo/config.toml[target.x86_64-unknown-linux-gnu]linker = "clang"rustflags = ["-C", "link-arg=-fuse-ld=mold"][alias]b = "build"c = "check"t = "test"r = "run"

Зачем это всё

Большинство «странных» проблем у новичков — не Rust, а сломанный rustup, конфликт toolchain’ов или старый rust-analyzer. Один день на нормальную настройку экономит месяц мучений.

Этап 1. Базовый синтаксис — привыкаешь к новому языку

Что учить

Переменные, типы, control flow, функции, базовые коллекции (Vec, String, HashMap), модули. Это 1-2 недели для человека, который уже знает любой системный язык, и 3-4 недели для пришедших из Python/JS.

Где ломаются

На String vs &str. Это первое столкновение с системой типов Rust: одна и та же «строка» имеет минимум два представления, и компилятор требует осознанного выбора. Не воспринимай это как раздражение — это лучшая тренировка перед ownership.

Первый код, который должен работать

fn greet(name: &str) -> String {    format!("Привет, {}!", name)}fn main() {    let name = String::from("мир");    println!("{}", greet(&name));    // name всё ещё валиден - мы передали ссылку, не владение}

Если ты понимаешь, почему здесь работает &name и что было бы, если передать просто name — этап 1 пройден.

Проект этапа

CLI-калькулятор или конвертер единиц. 100-200 строк, без external crates.

Этап 2. Владение, заимствование, времена жизни — здесь сломается большинство

Что учить

Ownership, borrowing, &T vs &mut T, lifetimes, перемещение значений, Copy vs Clone. Главы 4 и 10 The Rust Book + раздел про lifetimes в Rust by Example.

Где ломаются

Это самая сложная и самая важная глава Rust. На этом этапе случается момент: «я не понимаю, почему компилятор ругается, и я устал». Это нормально.

Главная ошибка — бороться с borrow checker’ом, добавляя .clone() везде. Работает, но Rust теряет смысл. Правильнее остановиться и переосмыслить структуру данных.

Проект этапа

Реализуй упрощённый Vec<T> или односвязный список. Это классический тест: если ты можешь написать односвязный список на Rust без подсказок — первый барьер пройден. У Aria Beingessner есть знаменитая статья «Learn Rust With Entirely Too Many Linked Lists» — проходи параллельно.

Контрольная точка после этапа 2

Объясни, почему этот код не компилируется, и предложи три способа починки:

fn main() {    let mut s = String::from("hello");    let r1 = &s;    let r2 = &mut s;    println!("{}, {}", r1, r2);}

Можешь — двигайся дальше. Нет — возвращайся к главе 4 The Rust Book. В спешке этот этап не проходится.

Этап 3. Структуры данных и абстракции — складываешь конструктор

Что учить

struct, enum, impl, методы, ассоциированные функции, traits, generics, trait bounds. The Rust Book главы 5, 10. Параллельно: Rust API Guidelines — как принято писать публичные API.

Generic-функция с trait bounds

use std::fmt::Display;fn longest<'a, T: Display>(items: &'a [T]) -> Option<&'a T> {    items.iter().max_by_key(|item| item.to_string().len())}fn main() {    let words = vec!["короткое", "длинноватое", "среднее"];    if let Some(w) = longest(&words) {        println!("самое длинное: {}", w);    }}

Здесь T: Display — trait bound, 'a — lifetime, и обе вещи становятся естественными к концу этого этапа.

Где ломаются

На trait bounds сложнее T: Clone + Send. Когда появляются ассоциированные типы, blanket impls, where-clauses — это первый намёк на устройство стандартной библиотеки. В production-коде такое встречается редко.

Проект этапа

Мини-ORM-like билдер запросов или конвертер форматов (JSON ↔ TOML ↔ YAML) с собственными trait-абстракциями.

Этап 4. Обработка ошибок и тестирование — делаешь код, который не стыдно показать

Что учить

Result<T, E>, Option<T>, оператор ?, thiserror для библиотек, anyhow для приложений, #[test], cargo test, proptest и insta для серьёзных проверок. Хороший разбор: Error Handling in Rust by BurntSushi.

Три стратегии работы с ошибками

// 1. Для прототипов: Box<dyn Error> - быстро, но без типизацииfn quick(path: &str) -> Result<String, Box<dyn std::error::Error>> {    Ok(std::fs::read_to_string(path)?)}// 2. Для приложений: anyhow - удобный контекст, без типизации ошибокfn app(path: &str) -> anyhow::Result<String> {    use anyhow::Context;    std::fs::read_to_string(path)        .with_context(|| format!("не смог прочитать {}", path))}// 3. Для библиотек: thiserror - типизированные ошибки для потребителей#[derive(thiserror::Error, Debug)]pub enum ConfigError {    #[error("файл {0} не найден")]    NotFound(String),    #[error("невалидный TOML: {0}")]    Parse(#[from] toml::de::Error),}

Личное наблюдение

В первых проектах все суют anyhow везде — ? с ним работает магически, и это нормальный старт. Но как только пишешь библиотеку, которой будут пользоваться другие — переходи на thiserror. Твои ошибки должны быть типизированными, не строковыми.

Проект этапа

Возьми CLI-утилиту с этапа 2 и переработай: добавь свои error-типы через thiserror, unit-тесты, integration-тесты, property-based тесты для одной критичной функции. Заведи CI на GitHub Actions с cargo fmt, cargo clippy -- -D warnings и cargo test.

Этап 5. Умные указатели и интериор-мутабельность — перестаёшь бояться Arc

Что учить

Box<T>, Rc<T>, Arc<T>, RefCell<T>, Cell<T>, Mutex<T>, RwLock<T>, Cow<T>. Когда какой использовать и почему. The Rust Book главы 15-16. Дополнительно — The Rustonomicon для тех, кто хочет понять внутренности.

Пример «до/после»

Типичная история: новичок пишет дерево через Box<Node> и упирается в то, что у узла не может быть нескольких родителей. Решение — переход к Rc<RefCell<Node>> для дерева в одном потоке или к Arc<Mutex<Node>> для многопоточного случая. Становится ясно, зачем эти типы вообще нужны и почему их нельзя смешивать как попало.

use std::rc::Rc;use std::cell::RefCell;type NodeRef = Rc<RefCell<Node>>;struct Node {    value: i32,    children: Vec<NodeRef>,    parent: Option<NodeRef>,}

Проект этапа

Графовая структура с обходом в ширину и в глубину. Сначала на Vec<Vec<usize>> (adjacency list — чаще всего этого хватает), потом на Rc<RefCell> со взаимными ссылками. Разница в сложности станет очевидной.

Этап 6. Многопоточность — параллелизм, который компилируется или не падает

Что учить

std::thread, std::sync (Mutex, RwLock, Arc, Barrier, Condvar), crossbeam для каналов и эпохального GC, rayon для параллельных итераторов, parking_lot для быстрых мьютексов. Trait’ы Send и Sync, что они в действительности означают.

Главная мысль этапа

Rust не делает многопоточку быстрее. Он делает её корректнее. Data race — это compile error.

Это меняет процесс разработки: вместо «запустил, увидел рандомный краш через 10 минут» получаешь «не скомпилировалось, потому что shared mutable state без синхронизации».

Пример

use std::sync::{Arc, Mutex};use std::thread;let counter = Arc::new(Mutex::new(0));let mut handles = vec![];for _ in 0..10 {    let c = Arc::clone(&counter);    handles.push(thread::spawn(move || {        let mut n = c.lock().unwrap();        *n += 1;    }));}for h in handles { h.join().unwrap(); }println!("{}", *counter.lock().unwrap()); // всегда 10

Проект этапа

Параллельный word-counter для больших файлов через rayon, потом thread pool на каналах через crossbeam. Сравни с однопоточной версией на гигабайтном файле — почувствуешь, ради чего всё это.

Этап 7. Асинхронное программирование — где живёт большинство production-багов

Что учить

async/await, tokio как стандарт de facto, axum для HTTP-серверов, reqwest для клиентов, sqlx или sea-orm для БД. Tokio Tutorial — лучший вход.

С 1.75 (декабрь 2023) async fn можно объявлять в трейтах напрямую, но с оговорками: для dyn Trait это работает иначе, для Send-границ нужен атрибут #[trait_variant::make(Send)] или старый крейт async-trait (в библиотеках он остаётся стандартом). Место, где новички спотыкаются регулярно.

Cancellation safety и structured concurrency

Главная подстава async-Rust для пришедших из Go и JS — cancellation. Future в Rust можно отменить в любой await-точке. Если внутри select! твой код держит частично записанное состояние — получишь corrupted state без всякого паники.

Помогает дисциплина: для одновременного запуска задач предпочитай tokio::JoinSet вместо ручного spawn + сборки хендлов, для отмены — CancellationToken из tokio-util, для select — проверяй, что каждая ветка cancellation-safe (это явно указано в документации tokio для большинства async-методов).

use tokio::task::JoinSet;let mut set = JoinSet::new();for url in urls {    set.spawn(fetch(url));}while let Some(res) = set.join_next().await {    // обрабатываем результат, при падении одной - остальные продолжают}

Graceful shutdown

Сервис должен уметь завершаться без потерь in-flight запросов. Базовый паттерн:

use tokio::signal;use tokio_util::sync::CancellationToken;let token = CancellationToken::new();let child = token.child_token();let server = tokio::spawn(async move {    run_server(child).await});signal::ctrl_c().await.unwrap();println!("получен SIGINT, завершаемся");token.cancel();server.await.unwrap();

Это вопрос на любом интервью на middle+. Готовь паттерн заранее.

Tracing — без него production невозможен

В синхронном Rust ты можешь дебажить println’ами. В async — нет: задачи переключаются между потоками, стек не поможет. Ставь tracing и tracing-subscriber сразу при создании проекта, добавляй #[tracing::instrument] на все async-функции, выводи в JSON для прода. Это обязательная часть инфраструктуры, не «когда-нибудь потом».

Проект этапа

HTTP-сервис на axum: эндпоинт, который ходит во внешний API, кеширует ответы в Redis, пишет в Postgres через sqlx. Добавь graceful shutdown, structured logging через tracing, метрики через metrics, интеграционные тесты с testcontainers.

Контрольная точка после этапа 7

Сделай pet-проект на 500-1500 строк, который реально работает на сервере хотя бы неделю. Сервис-сокращатель ссылок, бот в Telegram, прокси с rate limiting — что угодно. Можешь поддерживать его и расширять без переписывания с нуля — переходи к следующим этапам.

Этап 8. Макросы и метапрограммирование — расширяешь сам язык

Что учить

Декларативные макросы (macro_rules!), процедурные макросы трёх видов (derive, attribute, function-like), крейты syn и quote. Книга-эталон — «The Little Book of Rust Macros».

Простой macro_rules — с него начинают все

macro_rules! hashmap {    ($($key:expr => $val:expr),* $(,)?) => {{        let mut m = std::collections::HashMap::new();        $( m.insert($key, $val); )*        m    }};}fn main() {    let m = hashmap! {        "one" => 1,        "two" => 2,    };    println!("{:?}", m);}

90% макросов в кодовой базе — именно такие. Они полностью покрывают потребность в DSL без захода в proc-macros.

Личное наблюдение

Не пиши процедурные макросы, пока действительно не понадобятся. Когда дойдёшь — сначала смотри готовые крейты: darling для парсинга атрибутов сильно упрощает жизнь, и почти всегда подключай syn с фичей full — без неё парсинг сложных конструкций ломается на неочевидных местах.

Где это нужно

Если используешь #[derive(Serialize, Deserialize)] из serde — ты уже зависишь от proc-macros. Свои писать нужно для DSL внутри фреймворка или для устранения boilerplate в больших проектах.

Проект этапа

Реализуй простой derive-макрос: #[derive(Builder)], который генерирует builder-паттерн для структуры. Это классическое упражнение и хороший вход в мир syn/quote.

Этап 9. Unsafe Rust и FFI — спускаешься в подвал

Что учить

Что можно делать в unsafe-блоке (всего пять операций), The Rustonomicon, FFI с C через extern "C", #[repr(C)], биндинги через bindgen и cbindgen. Понятие undefined behavior и почему оно опаснее обычного бага.

Главная мысль про unsafe

unsafe — не «выключить безопасность». Это контракт: инварианты, которые обычно проверяет компилятор, ты гарантируешь сам.

Стандартная библиотека внутри полна unsafe-кода, но он завёрнут в безопасные интерфейсы.

Как правильно оформлять unsafe-блок

/// # Safety/// Указатель ptr должен быть валидным, выровнен на T и/// указывать на инициализированное значение, владение которым/// принадлежит вызывающей стороне.unsafe fn read_owned<T>(ptr: *mut T) -> T {    // SAFETY: контракт гарантирует валидность и владение.    // Дублирование запрещено: ptr нельзя использовать после этого вызова.    std::ptr::read(ptr)}

Два правила, которые делают unsafe-код поддерживаемым: # Safety секция в doc-комментарии и SAFETY: комментарий перед каждым unsafe-блоком, где явно сказано, какой именно инвариант гарантирован.

Soundness — концепт, который надо понять

Sound API — такой, где никакая комбинация безопасных вызовов не приводит к UB. Если кто-то может вызвать твою библиотеку без unsafe и получить use-after-free — твоя библиотека unsound. Это не «бэйджик за качество», это базовое требование к публичной API. Когда такое находят в популярных крейтах — выпускают yanked-версию и пишут постмортем.

Полезные инструменты

• miri — интерпретатор MIR, ловит UB в unsafe-коде (cargo +nightly miri test);

• loom — тестирование concurrent-кода с перебором interleavings;

• cargo-fuzz для fuzz-тестирования с libFuzzer;

• Address Sanitizer для отладки FFI-кода.

Проект этапа

Сделай safe-обёртку над какой-то C-библиотекой (zlib, libcurl, что-то простое). Полноценное упражнение на FFI плюс осознание того, чем «safe» отличается от «не падает на твоих тестах».

Этап 10. Экосистема и реальные проекты — выходишь в open source

Что учить

• сборка и публикация крейтов: cargo publish, версионирование, semver;

• workspaces для многокрейтных репозиториев;

• инфраструктура зрелого проекта: cargo-deny (политики зависимостей и лицензий), cargo-audit (проверка CVE), cargo-machete (поиск неиспользуемых зависимостей), cargo-nextest (быстрый тест-раннер);

• бенчмаркинг через criterion;

• кросс-компиляция через cross;

• профилирование — flamegraph, perf, samply.

Минимальный CI для крейта на crates.io

# .github/workflows/ci.ymlname: CIon: [push, pull_request]jobs:  test:    runs-on: ubuntu-latest    steps:      - uses: actions/checkout@v4      - uses: dtolnay/rust-toolchain@stable        with: { components: rustfmt, clippy }      - run: cargo fmt --check      - run: cargo clippy -- -D warnings      - run: cargo test --all-features

С этим минимумом твой крейт уже выглядит профессионально.

Где брать первый open source-опыт

This Week in Rust ведёт раздел «Call for Participation», там еженедельно публикуют issue с меткой «good first issue» из больших проектов. Хороший заход — найти проект, которым ты сам пользуешься, и закрыть один баг или улучшить документацию. Контрибьюторы крупных крейтов почти всегда отвечают доброжелательно.

Проект этапа

Опубликуй свой первый крейт. Не обязательно революционный — утилита для конкретной узкой задачи, которой пользуешься сам. Цикл от cargo new до cargo publish нужно пройти руками.

Этап 11. Уровень профи — то, что отделяет senior от middle

Что учить

• глубокая типовая магия: HRTB, GAT (generic associated types), type-level programming через типажи-маркеры;

• variance и PhantomData — зачем они и когда нужны;

• const generics в production-сценариях (массивы, размерности тензоров);

• понимание borrow checker до уровня intuition — предсказываешь ошибки до компиляции;

• MIR и оптимизации компилятора — Rust Compiler Development Guide;

• модель памяти Rust (пока формально не зафиксирована, но есть aliasing model Stacked Borrows / Tree Borrows);

• продвинутые async-паттерны: pinning, собственные Future, runtime-агностичные библиотеки.

GAT — пример того, что появляется только на этом уровне

Generic associated types (стабилизированы в Rust 1.65) позволяют параметризовать ассоциированные типы трейтов. Самый понятный сценарий — lending iterator: итератор, который выдаёт ссылки на свой внутренний буфер.

trait LendingIterator {    type Item<'a> where Self: 'a;    fn next(&mut self) -> Option<Self::Item<'_>>;}

До GAT такое было невыразимо в Rust без обходных манёвров. Если понимаешь, зачем здесь Item<'a> и почему нужен where Self: 'a — ты на этом уровне.

HRTB — higher-ranked trait bounds

for<'a> нужен, когда замыкание должно работать с любым lifetime, а не с конкретным. Классический пример:

fn apply<F>(f: F) where F: for<'a> Fn(&'a str) -> &'a str {    let s = String::from("hello");    println!("{}", f(&s));}

Без for<'a> компилятор зафиксирует один конкретный lifetime, и более общие замыкания не подойдут.

Variance в одном предложении

Variance определяет, как параметризованный тип «наследует» отношения подтипирования своих параметров. На практике это всплывает в FFI и собственных smart-pointer’ах — там без PhantomData<T>, PhantomData<fn() -> T> или PhantomData<*const T> поведение borrow checker’а становится неинтуитивным.

Что должно быть в голове

В этой точке ты умеешь читать сложные ошибки borrow checker’а и быстро понимать, где компилятор прав, а где можно перестроить код. На реальных интервью в senior+ роли этот навык проверяют живыми задачами.

Контрольная точка после этапа 11

Можешь объяснить, почему Pin нужен для самореферентных Future, без обращения к документации. Знаешь разницу между Send и Sync на уровне «какой инвариант обеспечивает каждый». Хотя бы раз сделал контрибьют в популярный крейт уровня tokio/serde/clap, и он был принят.

Частые ошибки новичков

Грабли, которые я наблюдаю годами в чатах и pull request’ах:

• Переписывание Python/JS-кода один-в-один. Структуры данных в этих языках построены на shared mutable state. В Rust такой код заставит обмазать всё Rc<RefCell> или Arc<Mutex> и потерять весь смысл языка. Сначала переосмысли структуру: где данные живут, кто ими владеет, кто читает.

• .clone() как способ заткнуть компилятор. Работает, но скрывает проблему дизайна. Если клонируешь большую структуру в цикле — почти наверняка можно передать ссылку. Если приходится клонировать String в каждой итерации — подумай про Cow<str>.

• unwrap() в production-коде. Для прототипа нормально, для прода — нет. Замени на ? с понятным error-типом либо на expect("осмысленное сообщение") там, где panic действительно ожидаем.

• Избегание unsafe любой ценой. unsafe не зло. Зло — unsound API, который снаружи выглядит безопасным. Иногда правильный путь — небольшой unsafe-блок с инвариантом в комментарии вместо громоздкой safe-обёртки.

• Преждевременная оптимизация на типах. Не пиши generic-функции с пятью trait bounds сразу. Сначала конкретные типы, потом, когда виден паттерн — generic.

• Игнор clippy. Включи cargo clippy -- -D warnings в CI с самого начала. Clippy ловит десятки антипаттернов, которые иначе остаются в кодовой базе.

• Зависимости без меры. cargo add ставится за секунду, но каждая зависимость — это время компиляции, поверхность атаки и потенциальный maintenance burden. На pet-проекте 10-15 зависимостей разумно, 100+ — повод задуматься.

До коммита в rustc

Самая высокая точка roadmap’а — попасть в команду компилятора. Не обязательно для карьеры, но лучшая школа, которую можно представить.

Путь обычно такой:

1. Стать активным контрибьютором в tokio, serde, rust-analyzer или cargo. Это уровень «senior+ в Rust».

2. Параллельно читать Rustc Dev Guide и пробовать собрать компилятор локально. Готовься: полная сборка занимает 30-90 минут на нормальной машине.

3. Найти E-easy issue в rust-lang/rust и сделать PR. Это занимает обычно несколько вечеров с непривычки.

4. После 3-5 принятых PR можно претендовать на статус reviewer в одной из команд (compiler, lang, libs).

Первый PR в rustc от issue до merge почти всегда занимает 2-4 недели. CI длинный, очереди ревью длинные, авторы перфекционисты. Это не отказ — это норма процесса.

Реалистичный срок до устойчивого контрибьюта — 2-4 года с момента, как начал писать на Rust серьёзно. У некоторых получается быстрее, у большинства не получается вовсе, и это нормально. Контрибьют в rustc не цель сам по себе.

Часть 2. Куда расти после roadmap

После того как этапы 0-11 пройдены, варианты ветвления:

• Systems programming. Ядро Linux (Rust-for-Linux уже в апстриме), eBPF, гипервизоры, файловые системы. Самая «классическая» ниша.

• Embedded и IoT. No-std, embedded-hal, RTIC, embassy для async на микроконтроллерах. Хороший вход — Embedded Rust Book.

• WebAssembly. wasm-bindgen, Yew/Leptos/Dioxus для фронтенда, WASI для server-side WASM. Здесь Rust сейчас лидер по экосистеме.

• Базы данных и big data. TiKV, Materialize, Polars, DataFusion, InfluxDB. Полно вакансий и интересных задач.

• Криптография и блокчейн. Solana, Polkadot, многие L2-проекты на Ethereum. Платит хорошо, требует осторожности с выбором работодателя.

• Compiler/language design. Rustc, Cranelift, разработка собственных языков на Rust.

• DevOps-тулинг. Vector, OpenTelemetry, sccache — инструменты, которые ставятся миллионами.

• AI/ML инфраструктура. candle, burn, tokenizers от HuggingFace — быстрорастущая область.

Не нужно выбирать всё. Хватит одной-двух ниш, в которых ты глубже середняка.

Слабые места Rust, о которых редко говорят

Маркетинговые статьи рассказывают про zero-cost abstractions и memory safety. Вот обратная сторона.

Технические

• Долгая компиляция. На большом проекте полный билд может занимать 5-15 минут, инкрементальные сборки — 30-90 секунд. Помогают workspaces, sccache, отключение лишних фич, mold как линкер. Проблема остаётся.

• Async-сложность. Pin, Future, ручная реализация runtime, cancellation safety — самые тяжёлые темы в языке. Многие senior-разработчики на Rust не пишут свои Future руками за всю карьеру.

• GUI-фреймворки незрелые. egui, iced, slint, Tauri — все они либо нишевые, либо в активной разработке. До уровня Qt и Flutter им далеко.

• Game dev в начале пути. Bevy красивый и быстро развивается, но индустрия пока на Unreal и Unity. Брать Rust первым языком для game dev — спорное решение.

• Rust Edition. Edition (2015/2018/2021/2024) — снимки синтаксиса и небольших правил, которые backward-compatible: код на разных edition в одном проекте дружит, при апдейте нужен cargo fix --edition. Иногда подкидывает сюрпризов в legacy-проектах.

Рыночные

• Сложность найма. Rust-разработчиков мало, и хороший Rust-разработчик стоит дорого. Это плюс для того, кто его учит, и минус для компании, которая внедряет.

• Документация неравномерна. Стандартная библиотека и популярные крейты документированы отлично. Но как только попадаешь в среднестатистический крейт — можешь обнаружить README на одну страницу и ничего больше.

• Высокий порог входа. Не миф. От «знаю синтаксис» до «пишу production-код уверенно» проходит 6-18 месяцев активной работы. Не у всех есть это время.

Это не аргументы против Rust. Это аргументы против иллюзий.

Crate-замены привычных инструментов

Если приходишь из Python, Node или Go — вот шпаргалка по экосистеме:

Rust и AI-инструменты в 2026

LLM-помощники сильно изменили процесс разработки на Rust за последние два года. Картина по моему опыту такая:

• Где помогают. Boilerplate, генерация impl стандартных трейтов, преобразование данных между форматами, написание тестов, подсказки по стандартной библиотеке, миграции между версиями фреймворков. На задачах уровня «напиши axum-эндпоинт, который делает X» современные модели справляются уверенно.

• Где врут. Async-трейты, lifetimes сложнее одного параметра, неочевидные правила coherence для трейтов, новые фичи языка (GAT, async closures), макросы из малопопулярных крейтов. Модель уверенно пишет код, который не компилируется, и зачастую сама не может это починить с трёх попыток.

• Что лучше работает. Современные большие модели (Claude, GPT, Gemini верхних линеек) заметно лучше справляются с Rust, чем линейки прошлого поколения. Но borrow checker всё ещё слабая зона: модель может предложить четыре варианта починки lifetime-ошибки, и три из них не компилируются.

IDE-агенты сильнее чатов

Cursor, Continue, Zed-агенты и rust-analyzer + LLM плагины помогают на Rust заметно лучше чатовых LLM. Причины две: они видят весь проект (а не один сниппет в окне чата) и читают вывод cargo check после каждой правки. Это закрывает главную слабость моделей на Rust — незнание точного API крейтов в твоей версии. К 2026 году это уже стандарт работы, а не экзотика.

Практический рецепт

Используй LLM как «junior, который пишет первый набросок», не как авторитет. Всегда запускай cargo check и cargo clippy на сгенерированном коде. Не доверяй объяснениям модели на тему, почему компилятор «должен» это пропустить.

В перспективе всё это будет улучшаться. Текущий вывод простой: Rust требует понимания, LLM не заменяет его, она ускоряет рутину.

Деньги: вилки зарплат и рынок

Оговорка: цифры ниже — усреднение по открытым вилкам, опросам Stack Overflow и публичным данным с конца 2024 — начала 2026. Конкретно у тебя может быть как лучше, так и хуже.

Особенности рынка:

• Junior-позиций мало. Большинство компаний хотят сразу Middle с самостоятельностью. Путь через pet-проекты и open source для Rust важнее, чем для других языков.

• Крипто-проекты исторически платят верхнюю границу диапазонов, но риски (волатильность, остановки выплат, репутация) выше. Внимательно проверяй работодателя.

• Embedded-Rust и core-инфраструктура часто платят меньше web-Rust, при этом задачи интереснее. Сознательный размен, на который многие идут.

• Удалёнка для Rust остаётся нормой даже там, где общий рынок откатился к гибриду.

Будни Rust-разработчика

Хайп вокруг языка иногда создаёт впечатление, что Rust-разработчик каждый день пишет lock-free структуры данных и оптимизирует кеш-линии. Реальность скучнее.

Если ты работаешь в продуктовой компании, типичные задачи такие: новая ручка в HTTP-API, миграция схемы БД, рефакторинг старого модуля, починка флака в тестах, доработка retry-логики у внешнего API-клиента, обновление зависимостей. Технически это CRUD на axum + sqlx + tracing, с теми же бизнес-проблемами, что в Python или Go.

Где Rust заметно отличается:

• Меньше runtime-инцидентов. То, что в Python ловтся мониторингом в проде, в Rust ловится cargo check. Это снижает стресс.

• Код-ревью идут дольше. Borrow checker и типы заставляют ревьюера думать о владении данными — полезное замедление.

• Зависимости обновляются осторожнее. cargo update на большом проекте может потянуть час разбирательств с breaking changes.

• Меньше «пятничных хотфиксов». В Rust сложнее быстро накатить горячую правку и удивиться поведению, поэтому культура чаще тяготеет к нормальному CI/CD.

Если идёшь в Rust ради хардкора каждый день — возможно, разочаруешься. Если идёшь ради меньшего количества боли в долгосрочной поддержке — попадёшь точно.

Как искать первую Rust-работу

Junior-вакансий на рынке мало, и стандартный путь «прислать резюме на 50 объявлений» в Rust работает плохо. Что работает:

• Pet-проекты на GitHub важнее опыта. В резюме первая строка после контактов — ссылка на 2-3 ярких проекта. Они должны компилироваться с CI, иметь README с примером запуска и понятный код. Это закрывает 80% сомнений нанимающего.

• Open source как лестница. Один принятый PR в популярный крейт (tokio, axum, clap) даёт больше веса, чем диплом. Hiring-менеджеры эти крейты знают.

• Где смотреть вакансии: jobs.rust-lang.org, rustjobs.dev, раздел Jobs в This Week in Rust, GitHub Jobs (фильтр Rust), hh.ru и LinkedIn (по тегам Rust + tokio/axum/sqlx).

• Стажировки и грантовые программы. Outreachy и Google Summer of Code регулярно берут проекты Rust-экосистемы. Это легальный путь к коммерческому опыту без коммерческого работодателя.

• Конференции и митапы. RustConf, RustFest, локальные митапы. Половина первых офферов на Rust в чатах знакомых пришла через нетворкинг, не через резюме.

• Фриланс через консалтинг. Mainmatter (бывшая Ferrous Systems), Tweede golf, Embecosm — примеры компаний, регулярно ищущих Rust-консультантов. Порог входа высокий, но это шанс начать с интересных проектов.

Главное: первый Rust-оффер обычно приходит дольше, чем первый Python- или Go-оффер. На это закладывайся.

Как устроены интервью на Rust в 2026

Структура обычная для индустрии, но с акцентами:

1. Скрининг. Лёгкая задача на алгоритмы + 2-3 вопроса по языку (ownership, traits, обработка ошибок).

2. Лайв-кодинг. Чаще всего просят написать что-то на 50-100 строк с использованием стандартной библиотеки. Главное — не идеальный код, а как ты рассуждаешь и реагируешь на ошибки компилятора.

3. Системный дизайн. Спрашивают про конкретные технологии: tokio, axum, sqlx. Готовься объяснять, почему выбираешь Arc<Mutex> vs канал, как делаешь backpressure, как организуешь graceful shutdown.

4. Глубокий разбор. Иногда дают код с багом и просят его найти. Классика — утечка Arc-цикла, dead lock на Mutex, неправильная cancellation safety в select!.

5. Поведенческое интервью. Стандартное, ничего специфичного для Rust.

Что спрашивают чаще всего: Send vs Sync, Box vs Rc vs Arc, ?Sized, как работает async fn, что такое Pin и зачем он нужен. На senior+ — модель памяти, оптимизации, профилирование.

Что готовить заранее: 1-2 своих проекта, про которые можешь рассказывать 20 минут с архитектурными решениями. Без этого пройти middle+ интервью почти невозможно.

Анти-FAQ

Самые частые вопросы от тех, кто думает, начинать ли:

• Стоит ли учить Rust первым языком программирования? Скорее нет. Кривая обучения слишком крутая, и многие концепции (ownership, lifetimes) проще понимать после опыта с указателями в C или сборщиком мусора в Java/Python. Возьми Python или Go первым, через полгода-год переходи на Rust.

• Стоит ли учить Rust после Python для бэкенда? Зависит от задач. Если у тебя CRUD без жёстких требований к латентности — Python остаётся продуктивнее. Если упираешься в производительность или хочешь снизить расходы на инфраструктуру — да, тогда Rust окупится.

• Стоит ли учить Rust после C++? Скорее да. Это твой профильный язык будущего: базовые концепции ты уже понимаешь, остаётся принять borrow checker и async-модель. Многие C+±разработчики говорят, что Rust изменил их и C+±код в лучшую сторону.

• Стоит ли учить Rust для game dev? Зависит от целей. Для коммерческой студии — нет, индустрия на Unreal и Unity. Для собственного движка или экспериментов с Bevy — почему бы и нет.

• Стоит ли учить Rust для ML? Ядро ML остаётся на Python (PyTorch, JAX). Но инференс-инфраструктура, токенайзеры, сервинг моделей — всё чаще на Rust, и это растущая ниша.

• Стоит ли учить Rust ради зарплаты? Стоит, но не как самоцель. Rust-вакансий мало, конкуренция за хорошие позиции жёсткая, junior-роли в дефиците. Если учишь только из-за денег — возможно, Go даст результат быстрее.

• Сколько займёт стать продуктивным? До «могу писать рабочий код» — 2-3 месяца активной практики. До «беру с улицы middle-задачу и закрываю её» — 9-18 месяцев. До senior — годы.

Что почитать и посмотреть

С пометками от меня — что кому подойдёт.

Книги:

• The Rust Programming Language — обязательно, бесплатно, идеальный первый шаг. Если ты прочитал её и понял главы 4 и 10 — дальше пойдёт легче.

• Programming Rust (Blandy, Orendorff, Tindall) — более глубокий учебник, подходит тем, кто хочет понять «почему именно так». Стоит брать после Rust Book.

• Rust for Rustaceans (Jon Gjengset) — для тех, кто уже пишет на Rust полгода и хочет дойти до senior. Не учебник, а сборник тем, которые редко проговаривают вслух.

• Rust Atomics and Locks (Mara Bos) — бесплатно онлайн, лучшая книга про модель памяти и concurrency на Rust. Маст-рид перед серьёзной многопоточкой.

• Zero to Production in Rust (Luca Palmieri) — проектно-ориентированная книга, ведёт от пустого репозитория до задеплоенного сервиса с CI, БД, тестами. Хороший практический материал после Rust Book.

Бесплатные онлайн-ресурсы:

• Rust by Example — примеры кода для всех ключевых концепций.

• Rustlings — упражнения для первого месяца.

• The Rustonomicon — для тех, кто полез в unsafe.

• Tokio Tutorial — лучший вход в async.

• The Little Book of Rust Macros — макросы.

• Comprehensive Rust — курс от Google.

YouTube-каналы:

• Jon Gjengset — длинные стримы с разбором популярных крейтов изнутри. Самый качественный Rust-контент на YouTube.

• Let’s Get Rusty — короткие туториалы, удобно для повторения.

• No Boilerplate — идеи и обзоры, не учебный материал, но полезно для общего кругозора.

Рассылки и подкасты:

• This Week in Rust — обязательная еженедельная рассылка.

• Rustacean Station — подкаст с разработчиками экосистемы.

Исходники, которые стоит прочитать:

• serde — чистая работа с traits и generics;

• tokio — реальный async-runtime;

• ripgrep — производительный CLI с продуманной архитектурой;

• clap — эталон работы с procedural-макросами.

Где общаться: сообщество

Rust — один из самых здоровых tech-комьюнити в индустрии, и общение в нём заметно ускоряет обучение.

Международные ресурсы для общения:

• r/rust — reddit-сообщество, отвечают на любые вопросы новичков.

• users.rust-lang.org — форум для вопросов по языку.

• internals.rust-lang.org — форум для обсуждения внутреннего устройства языка и компилятора.

• Rust Zulip — официальный чат разработчиков языка. Здесь работают команды compiler/lang/libs.

• Discord rust-lang — быстрые ответы по практическим вопросам.

• Стэк Stack Overflow с тегом rust — архивная база ответов.

Русскоязычные:

• Telegram-канал Rust | Программирование

• Чат русскоязычных Rust-разработчиков

• Сообщество ВКонтакте о Rust если с тг проблемы

Совет: задавай вопросы публично, даже если страшно. Хороший вопрос с минимальным воспроизводимым примером закроется за час, плохо сформулированный — не закроется никогда.

Чек-лист проектов для портфолио

К концу roadmap’а у тебя должны быть готовы 12 артефактов: настроенное окружение и 11 проектов.

0. Настроенный dev-env: rustup, rust-analyzer, шаблон Cargo.toml и .cargo/config.toml, готовый CI-workflow (этап 0).

1. CLI-калькулятор или конвертер единиц (этап 1).

2. Свой Vec или односвязный список (этап 2).

3. Мини-ORM-билдер или конвертер форматов (этап 3).

4. CLI-утилита с тестами, CI и тип-обёрткой над ошибками (этап 4).

5. Графовая структура с обходами (этап 5).

6. Параллельный word-counter через rayon и crossbeam (этап 6).

7. HTTP-сервис на axum + Redis + Postgres с tracing (этап 7).

8. Derive-макрос (например, Builder) на syn/quote (этап 8).

9. Safe-обёртка над C-библиотекой через bindgen (этап 9).

10. Опубликованный крейт на crates.io (этап 10).

11. Реализация Future руками или контрибьют в популярный крейт (этап 11).

Это не «обязательная программа», а карта проверок. Если в портфолио чего-то нет — этого нет и в голове.

Куда идти прямо сейчас

Один следующий шаг, в зависимости от того, где ты находишься:

• Никогда не писал на Rust. Открой The Rust Book и сделай первые два упражнения Rustlings. 30 минут сегодня.

• Прошёл Rust Book, не знаешь, что делать. Напиши CLI-утилиту на 200-300 строк, которую сам будешь использовать.

• Пишешь полгода, чувствуешь стагнацию. Возьми «Rust for Rustaceans» и tokio source. Будет тяжело и полезно.

• Готовишься к интервью. Открой 2-3 публичные roadmap-задачи в Rust LeetCode-репозиториях, порешай по одной в день и параллельно пиши short-summary своих pet-проектов.

• Хочешь open source. Раздел Call for Participation в This Week in Rust, выбери задачу с меткой good first issue в крейте, которым пользуешься. Закрой её до конца недели.

---

Rust не сделает тебя лучшим инженером сам по себе. Но он заставит думать о вещах, которые в других языках можно игнорировать годами — про владение данными, инварианты, границы ответственности модулей. Эта привычка остаётся в любом коде, который ты пишешь дальше.

Если roadmap зашёл — подписывайся на канал, посвященный Rust и кодингу, там обновления карты, разборы интервью и новые проекты. Если что-то пропустил или ошибся — пиши в комментариях, поправлю.

Спасибо, что дочитал! Замечания и советы по улучшению Роадмапа очень приветсвуются)