모던 Rust 2026 — Rust 1.85 / Edition 2024 / Tokio / Axum 0.8 / Loco / Leptos / Bevy / Tauri 2 / Embassy 심층 가이드

• 1장 · 2026년 모던 Rust — 2024 edition이 가져온 것
• 2장 · Rust 1.85 + Edition 2024 — gen blocks, async closures, never type fallback
  • 2.1 gen blocks — Iterator를 직접 안 짜도 된다
  • 2.2 async closures
  • 2.3 RPIT 라이프타임 캡처
  • 2.4 never type fallback
• 3장 · Tokio — async 런타임 표준
• 4장 · Axum 0.8 — Tower 기반 인기 웹 프레임워크
• 5장 · Actix-Web 4 / Rocket 0.5 — 성능 vs DX
  • 5.1 Actix-Web 4 — 벤치마크의 왕
  • 5.2 Rocket 0.5 — 마침내 async
• 6장 · Loco — Rails for Rust
• 7장 · Leptos 0.7 — fine-grained reactivity 프론트
• 8장 · Dioxus / Yew — React/Elm 스타일 옵션
  • 8.1 Dioxus — React-like
  • 8.2 Yew — Elm/React-like, 가장 오래된 선택
• 9장 · 데이터베이스 — sqlx / Diesel 2 / SeaORM
  • 9.1 sqlx — async, raw SQL, compile-time check
  • 9.2 Diesel 2 — sync ORM의 정석
  • 9.3 SeaORM — async ORM, ActiveRecord 스타일
• 10장 · Bevy 0.15 — ECS 게임 엔진
• 11장 · Tauri 2 — 데스크탑 + 모바일
• 12장 · ML — Burn / Candle / mistral.rs
  • 12.1 Candle — HuggingFace의 minimalist ML
  • 12.2 Burn — 모델 학습까지
  • 12.3 mistral.rs — LLM 추론 최적화
• 13장 · Embassy — async embedded
• 14장 · 도구 — cargo-binstall / rust-analyzer / RustRover / Helix
  • 14.1 cargo-binstall — 컴파일 없이 cargo 도구 설치
  • 14.2 cargo-watch — 파일 바뀌면 다시 돈다
  • 14.3 cargo-leptos — Leptos 전용 dev server
  • 14.4 cargo-mobile2 — Rust 모바일 빌드
  • 14.5 rust-analyzer — LSP
  • 14.6 RustRover — JetBrains 공식
  • 14.7 Helix — Rust로 짠 modal editor
• 15장 · 한국 / 일본 — 카카오, 토스, 메르카리, ZOZO, Sansan
  • 15.1 한국
  • 15.2 일본
• 16장 · 누가 Rust를 골라야 하나 — 시스템 / 임베디드 / 풀스택 / 게임
  • 16.1 Rust가 빛나는 곳
  • 16.2 Rust가 부담인 곳
  • 16.3 2026년 Rust 학습 로드맵
• 17장 · 참고 / References
  • 공식
  • 웹 / 백엔드
  • 프론트엔드
  • DB
  • 게임 / 데스크탑 / 모바일
  • ML
  • 임베디드
  • 도구 / IDE
  • 한국 / 일본 케이스

1장 · 2026년 모던 Rust — 2024 edition이 가져온 것

2025년 2월 20일, Rust 1.85가 풀렸다. 그리고 그 날, 2024 edition이 새 프로젝트의 기본값이 되었다. Rust edition은 3년 주기로 돌아오는 "언어 디자인의 결산"인데, 2015 → 2018 → 2021을 거쳐 4번째인 2024는 비동기와 라이프타임을 가장 크게 손봤다.

핵심 변화 5가지:

1. RPIT 라이프타임 캡처 규칙 변경 (-> impl Trait) — 이제 in-scope 라이프타임을 전부 캡처한다. 예전에 .unwrap()이나 boxed()로 우회하던 + '_ 헬게이트가 줄었다.
2. async fn이 trait에 정식 진입 — 1.75에서 stabilize된 AFIT가 2024 edition과 만나면서 dyn trait의 async도 라이브러리에서 쉽게 받는다.
3. gen 블록 / gen fn — Python의 generator 문법이 Rust에 들어왔다. Iterator 직접 짤 일이 줄어든다.
4. async closures (async ||) — 클로저에서 async move { ... }를 두 번 감싸는 패턴이 사라진다.
5. never type fallback이 !로 통일 — 예전엔 추론이 미묘하면 ()로 빠졌는데, 이제 !로 일관된다. 에러 메시지가 명확해지고, "왜 컴파일러가 이걸 골라?" 하던 순간이 줄어든다.

이 5가지가 합쳐지면 "2021 edition으로 짠 Rust"와 "2024 edition으로 짠 Rust"는 같은 언어 같지가 않다. 특히 웹/서버를 짜는 사람한테는 체감이 크다 — Tokio 1.x + Axum 0.8 + Tower의 조합이 이제 "Express 같은 경량 코드"에 근접해졌다.

이 글은 그 변화 위에 얹혀 있는 2026년 5월 시점의 Rust 생태계를 한 번에 본다. 웹·DB·게임·데스크탑·모바일·ML·임베디드·도구·IDE — 그리고 한국과 일본의 도입 현황까지.

2장 · Rust 1.85 + Edition 2024 — gen blocks, async closures, never type fallback

2.1 gen blocks — Iterator를 직접 안 짜도 된다

// 2021 edition: Iterator를 직접 구현
struct Counter { n: u32, max: u32 }
impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.n < self.max { self.n += 1; Some(self.n) } else { None }
    }
}

// 2024 edition (1.85, unstable gen 게이트 통과 시): gen fn
gen fn counter(max: u32) -> u32 {
    let mut n = 0;
    while n < max {
        n += 1;
        yield n;
    }
}

yield가 정식 키워드가 되고, gen fn은 자동으로 impl Iterator<Item = u32>로 컴파일된다. async 버전인 async gen / Stream 통합도 같은 트랙에서 굴러간다.

2.2 async closures

// 2021 edition: 클로저 안에서 async move {} 한 번 더 감쌈
let xs = vec![1, 2, 3];
let futs = xs.into_iter().map(|x| async move { process(x).await });

// 2024 edition: async closure 그 자체
let xs = vec![1, 2, 3];
let futs = xs.into_iter().map(async |x| process(x).await);

특히 tokio::spawn / futures::join_all / stream::then 같은 곳에서 코드가 한 줄씩 짧아진다.

2.3 RPIT 라이프타임 캡처

// 2021 edition: 'a를 명시적으로 캡처 못 하면 컴파일 에러
fn names<'a>(xs: &'a [String]) -> impl Iterator<Item = &'a str> + use<'a> {
    xs.iter().map(|s| s.as_str())
}

// 2024 edition: in-scope 라이프타임이 자동으로 캡처됨
fn names<'a>(xs: &'a [String]) -> impl Iterator<Item = &'a str> {
    xs.iter().map(|s| s.as_str())
}

+ use<'a> 같은 명시가 사라진다. 단점은 "예전엔 캡처 안 됐던 라이프타임"이 캡처되면서 일부 코드가 의도치 않게 못 쓰게 되는 경우가 있다 — migration lint가 잡아준다.

2.4 never type fallback

Result::Err::<i32, _>(panic!()) 같은 경우, 예전엔 _가 ()로 추론되어 묘한 trait 충돌이 났다. 이제 !로 빠진다. 라이브러리 매크로 작성자가 한숨 돌리는 변화다.

3장 · Tokio — async 런타임 표준

2026년 시점, Rust async 런타임은 Tokio 1.x가 사실상 단일 표준이다. 경쟁자는 async-std(개발 정체), smol(임베디드/단일 스레드), monoio(Cloudflare가 만든 io_uring 전용) 정도다.

Tokio가 표준이 된 이유:

• 에코시스템 무게: hyper, reqwest, sqlx, tokio-postgres, axum, tower, tonic 모두 Tokio 위에서 동작
• 스케줄러 품질: work-stealing 스케줄러가 Go의 GOMAXPROCS 수준의 성숙도
• tokio::select! / JoinSet / LocalSet 같은 일급 기능
• io_uring 지원(tokio-uring) — Linux에서 네트워크 IO를 syscall 한 번에 처리

// 가장 기본적인 Tokio 서버
use tokio::net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("0.0.0.0:8080").await?;
    loop {
        let (mut socket, _) = listener.accept().await?;
        tokio::spawn(async move {
            let mut buf = vec![0; 1024];
            loop {
                let n = match socket.read(&mut buf).await {
                    Ok(0) => return,
                    Ok(n) => n,
                    Err(_) => return,
                };
                if socket.write_all(&buf[..n]).await.is_err() { return; }
            }
        });
    }
}

#[tokio::main]은 멀티스레드 work-stealing 런타임을 만들고, tokio::spawn은 그 위에 태스크를 던진다. 단일 스레드가 필요하면 current_thread 런타임으로 가면 된다 — 임베디드/WASM에서 이 선택이 중요해진다.

4장 · Axum 0.8 — Tower 기반 인기 웹 프레임워크

Axum은 Tokio 팀이 직접 만드는 웹 프레임워크다. 2024년 11월에 0.8이 풀리면서 라우터 path syntax가 :id → {id} 스타일로 바뀐 게 가장 큰 변화다.

use axum::{Router, routing::get, extract::Path};

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/", get(|| async { "hello" }))
        .route("/users/{id}", get(get_user))
        .route("/health", get(|| async { "ok" }));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

async fn get_user(Path(id): Path<u64>) -> String {
    format!("user {}", id)
}

Axum의 매력:

1. Tower 미들웨어와 호환 — tower-http의 CompressionLayer, TraceLayer, CorsLayer를 그대로 끼움
2. Extractor가 함수 시그니처에 박힘 — Path, Query, Json, State를 인자로 받으면 자동 파싱
3. 타입으로 라우팅 보장 — 핸들러가 잘못된 시그니처면 컴파일 에러
4. WebSocket / SSE 일급 지원

use axum::{Json, extract::State};
use serde::{Deserialize, Serialize};

#[derive(Deserialize)] struct CreateUser { name: String }
#[derive(Serialize)] struct User { id: u64, name: String }

async fn create_user(
    State(db): State<DbPool>,
    Json(body): Json<CreateUser>,
) -> Json<User> {
    let id = sqlx::query_scalar!("INSERT INTO users(name) VALUES($1) RETURNING id", body.name)
        .fetch_one(&db).await.unwrap();
    Json(User { id: id as u64, name: body.name })
}

이 패턴이 2026년 Rust 백엔드의 사실상 표준이다. Loco도 이 위에 얹혀 있다.

5장 · Actix-Web 4 / Rocket 0.5 — 성능 vs DX

5.1 Actix-Web 4 — 벤치마크의 왕

TechEmpower benchmark에서 Actix-Web은 거의 모든 round에서 상위권을 지킨다. 자체 actor 시스템(actix)이 있긴 한데, 4.x는 tokio 호환성을 높여서 일반적인 async/await로 짜도 잘 돈다.

use actix_web::{get, web, App, HttpServer, Responder};

#[get("/users/{id}")]
async fn get_user(path: web::Path<u64>) -> impl Responder {
    format!("user {}", path.into_inner())
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().service(get_user))
        .bind("0.0.0.0:3000")?
        .run()
        .await
}

"숫자에서 1ms라도 더 짜낼 일"이 있으면 Actix를 본다. 단점은 에러 처리·미들웨어 API가 Axum/Tower 만큼 깔끔하지 않다는 거다.

5.2 Rocket 0.5 — 마침내 async

Rocket은 매크로 기반 macro-magic 스타일로 유명했지만, async 진입이 너무 늦었다(2023년 11월에야 0.5 stable). 2026년에는 학습용·내부 도구·취미용에서 여전히 매력적이지만, 프로덕션 무게의 새 프로젝트는 Axum/Loco로 빠지는 분위기.

#[macro_use] extern crate rocket;

#[get("/users/<id>")]
async fn get_user(id: u64) -> String { format!("user {}", id) }

#[launch]
fn rocket() -> _ {
    rocket::build().mount("/", routes![get_user])
}

직관적이긴 하다. 하지만 동일 기능을 Axum이 더 정직하게 짠다.

6장 · Loco — Rails for Rust

Loco는 2023년 8월에 처음 등장한, **"Rust의 Rails"**를 표방하는 풀스택 프레임워크다. Axum + sea-orm + tower + sidekiq-rs 같은 컴포넌트를 묶어 "scaffold 한 줄로 CRUD가 굴러가는" 경험을 만든다.

cargo install loco-cli
loco new my_app
cd my_app
cargo loco start

# Rails 같은 generator
cargo loco generate scaffold post title:string body:text
cargo loco db migrate
cargo loco start

이 두 줄이면 /posts CRUD 라우터, sea-orm 모델, 마이그레이션, validator, 그리고 view까지 생긴다. 백그라운드 워커는 Sidekiq, 이메일은 lettre, auth는 JWT — 묶음이 정해져 있어서 결정 비용이 낮다.

Loco의 포지션:

• Rails / Phoenix / Laravel을 좋아하지만 Rust로 가고 싶은 사람
• "내가 Rust로 뭘 골라야 할지" 하는 결정 피로가 큰 팀
• 단점: 묶음이 정해진 만큼, 그 묶음에서 벗어나려고 하면 일반 Axum 짜는 것보다 무겁다

2026년 시점, Loco는 0.13 근처에서 안정화 중이고, 한국·일본 스타트업에서도 "사이드 프로젝트로는 가장 부담 적은 Rust 풀스택"이라는 평이 늘고 있다.

7장 · Leptos 0.7 — fine-grained reactivity 프론트

Leptos는 SolidJS에서 영감을 받은 fine-grained reactivity 모델의 Rust 프론트엔드 프레임워크다. 0.7(2024 후반 → 2025 안정)에서 reactive system이 크게 다시 짜였고, SSR/hydration/islands가 한층 매끄러워졌다.

use leptos::prelude::*;

#[component]
fn Counter() -> impl IntoView {
    let (count, set_count) = signal(0);
    view! {
        <button on:click=move |_| set_count.update(|n| *n += 1)>
            "Count: " {count}
        </button>
    }
}

fn main() { leptos::mount::mount_to_body(Counter); }

Leptos의 매력:

1. VDOM이 없다 — signal이 직접 DOM 노드를 업데이트. React보다 빠르고 메모리도 적다
2. view! 매크로가 JSX 같은 문법을 제공
3. SSR + hydration이 Rust 한 언어로 풀린다 (Next.js 같은 분리가 없음)
4. **cargo-leptos**가 빌드/HMR/SSR 서버를 묶어준다
5. server functions — #[server] 매크로로 함수를 서버에서 실행, 클라이언트에서 호출

#[server(GetTodos)]
async fn get_todos() -> Result<Vec<Todo>, ServerFnError> {
    let pool = use_context::<DbPool>().expect("pool");
    sqlx::query_as!(Todo, "SELECT * FROM todos").fetch_all(&pool).await
        .map_err(|e| ServerFnError::new(e.to_string()))
}

이 함수는 클라이언트가 직접 호출할 수 있는 RPC가 된다 — type-safe, no boilerplate. Remix loaders / Next server actions / SolidStart actions와 동일한 컨셉이다.

8장 · Dioxus / Yew — React/Elm 스타일 옵션

8.1 Dioxus — React-like

Dioxus는 React에 가장 가까운 Rust 프론트엔드다. VDOM이 있고, hooks가 있고, 컴포넌트가 함수다. 2024년 0.6, 2025년에 0.7로 올라오면서 "데스크탑·모바일·웹·서버"를 한 트리에서 빌드한다.

use dioxus::prelude::*;

fn App() -> Element {
    let mut count = use_signal(|| 0);
    rsx! {
        button { onclick: move |_| count += 1, "Count: {count}" }
    }
}

fn main() { dioxus::launch(App); }

dioxus serve 한 줄로 데스크탑·웹·iOS·Android가 같은 코드에서 나온다 — Tauri / Capacitor와 다른, 자체 렌더러 트랙이다.

8.2 Yew — Elm/React-like, 가장 오래된 선택

Yew는 Rust 프론트엔드 중 가장 오래된(2017) 프로젝트로, Elm-ish 메시지 패턴에서 시작해 지금은 React-hooks와 비슷한 API로 정착했다. Leptos / Dioxus가 더 새 것 같지만, Yew는 안정성·문서가 좋다.

use yew::prelude::*;

#[function_component]
fn Counter() -> Html {
    let count = use_state(|| 0);
    let onclick = {
        let count = count.clone();
        Callback::from(move |_| count.set(*count + 1))
    };
    html! { <button {onclick}>{"Count: "}{*count}</button> }
}

fn main() { yew::Renderer::<Counter>::new().render(); }

선택 가이드 (2026년 5월 기준):

• Fine-grained 반응성 + SSR이 핵심 → Leptos
• React 친화 멘탈모델 + 풀스택 모바일/데스크탑까지 한 코드 → Dioxus
• 검증된 라이브러리·문서·튜토리얼 → Yew

9장 · 데이터베이스 — sqlx / Diesel 2 / SeaORM

9.1 sqlx — async, raw SQL, compile-time check

sqlx는 raw SQL을 쓰되, 컴파일 타임에 DB에 연결해서 쿼리를 검증한다. 매크로가 마법이다.

use sqlx::PgPool;

#[derive(sqlx::FromRow)]
struct User { id: i64, name: String }

async fn get_user(pool: &PgPool, id: i64) -> Result<User, sqlx::Error> {
    sqlx::query_as!(User, "SELECT id, name FROM users WHERE id = $1", id)
        .fetch_one(pool).await
}

query_as! 매크로가 컴파일 시점에 PostgreSQL과 연결해서 id/name 컬럼의 타입을 검증한다. CI에서 SQL 오타를 잡는다. 단점: 빌드 환경에 DB가 필요하다 (sqlx prepare로 offline 모드 가능).

9.2 Diesel 2 — sync ORM의 정석

Diesel은 sync API + 강력한 타입 기반 query builder. 2022년 2.0에서 ergonomics가 크게 좋아졌다. async가 필수가 아니면 (CLI, 단일 스레드 워커, 마이그레이션 도구) Diesel이 여전히 강하다.

use diesel::prelude::*;

#[derive(Queryable)]
struct User { id: i64, name: String }

let users: Vec<User> = users::table
    .filter(users::name.like("alice%"))
    .load(&mut conn)?;

9.3 SeaORM — async ORM, ActiveRecord 스타일

SeaORM은 sea-orm-cli로 DB에서 entity를 생성하고, Entity::find().filter(...).all(&db).await 같은 ActiveRecord-ish API를 제공한다. Loco가 SeaORM을 채택하면서 입지가 커졌다.

use sea_orm::{EntityTrait, QueryFilter, ColumnTrait};

let users = users::Entity::find()
    .filter(users::Column::Name.contains("alice"))
    .all(&db).await?;

선택:

• raw SQL이 편하고 컴파일 검증이 중요 → sqlx
• 타입 기반 query builder + sync OK → Diesel 2
• ORM 스타일 + async + 다양한 DB 지원 → SeaORM

10장 · Bevy 0.15 — ECS 게임 엔진

Bevy는 Rust의 대표 게임 엔진이고, ECS(Entity-Component-System) 아키텍처가 핵심이다. 2024년 11월에 풀린 0.15는 required components, animation system 재작성, picking, error handling 표준화가 핵심이다.

use bevy::prelude::*;

#[derive(Component)] struct Player;
#[derive(Component)] struct Velocity(Vec3);

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(Startup, spawn_player)
        .add_systems(Update, move_player)
        .run();
}

fn spawn_player(mut commands: Commands) {
    commands.spawn((Player, Velocity(Vec3::ZERO), Transform::default()));
}

fn move_player(time: Res<Time>, mut q: Query<(&mut Transform, &Velocity), With<Player>>) {
    for (mut t, v) in &mut q {
        t.translation += v.0 * time.delta_secs();
    }
}

ECS의 본질은 "데이터(Component)와 동작(System)을 분리하고, 시스템은 자신이 보고 싶은 컴포넌트 조합만 쿼리한다"이다. OOP 게임 코드에서 익숙한 다중 상속 / 거대한 base class가 없어진다.

2026년 시점 Bevy:

• 인디 게임 / Game Jam에서 점유율 빠르게 상승
• 큰 스튜디오는 Unity / Unreal을 못 떠나지만, "Unity가 가격 정책으로 흔들리는 동안 Rust 쪽으로 새기 시작한" 신호가 보임
• 약점은 여전히 에디터(공식 에디터가 아직 alpha)와 모바일 빌드 파이프라인

11장 · Tauri 2 — 데스크탑 + 모바일

Tauri는 Electron의 대안이다. webview를 native로 띄우고(macOS는 WKWebView, Windows는 WebView2, Linux는 WebKitGTK), 백엔드 로직은 Rust로 짠다. 2024년 10월에 풀린 Tauri 2의 가장 큰 변화는 모바일 (iOS / Android) 지원이다.

cargo install create-tauri-app
cargo create-tauri-app
cd my-app
cargo tauri dev

# iOS / Android 빌드
cargo tauri ios dev
cargo tauri android dev

Tauri vs Electron:

Electron의 압도적 강점은 "Chromium이 어디서나 같다"는 점이다. Safari WebKit / WebView2의 미묘한 차이를 디버깅해야 하는 게 Tauri의 비용이다. 그래도 메모리/바이너리 차이가 크고, Rust 백엔드가 주는 시스템 호출 안전성이 매력이다.

// src-tauri/src/lib.rs
#[tauri::command]
fn greet(name: &str) -> String { format!("Hello, {}!", name) }

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![greet])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

프론트엔드에서 await invoke('greet', { name: 'Alice' })로 호출하면 Rust 함수가 실행되고 결과가 돌아온다. RPC 코드 자동 생성, 권한(capability) 시스템, plugin 생태계가 v2에서 한층 다듬어졌다.

12장 · ML — Burn / Candle / mistral.rs

Rust ML 생태계는 2024-2025에 빠르게 자라났다. 핵심은 3개:

12.1 Candle — HuggingFace의 minimalist ML

Candle은 HF가 만든 "PyTorch보다 가볍고, ONNX보다 친근한" Rust ML 라이브러리다. WASM에 바로 컴파일되고, Metal / CUDA / CPU 백엔드를 골라 쓴다.

use candle_core::{Device, Tensor};

let device = Device::Cpu;
let a = Tensor::randn(0f32, 1.0, (2, 3), &device)?;
let b = Tensor::randn(0f32, 1.0, (3, 4), &device)?;
let c = a.matmul(&b)?;
println!("{:?}", c.shape());

candle-transformers에 LLaMA, Mistral, Whisper, Stable Diffusion 같은 모델이 이미 포팅돼 있다. 데스크탑/엣지에서 추론만 하려면 candle이 가장 가볍다.

12.2 Burn — 모델 학습까지

Burn은 학습/추론 모두를 Rust로 하려는 사람들을 위한 풀스택 ML 프레임워크다. PyTorch에 가까운 API, 백엔드 추상화(WGPU, CUDA, NdArray, LibTorch), autodiff.

use burn::tensor::{Tensor, backend::Backend};

fn linear<B: Backend>(x: Tensor<B, 2>) -> Tensor<B, 2> {
    let w = Tensor::random([784, 10], Distribution::Default, &x.device());
    x.matmul(w)
}

12.3 mistral.rs — LLM 추론 최적화

mistral.rs는 LLM 추론을 Rust로 가장 빠르게 짜낸 라이브러리 중 하나다. PagedAttention, quantization (GGUF, GPTQ, AWQ), grammar-constrained 출력, OpenAI 호환 server를 한 바이너리에 묶었다.

mistralrs-server --port 1234 plain -m mistralai/Mistral-7B-Instruct-v0.2

선택 가이드:

• 추론만 + 데스크탑/엣지 → Candle
• 학습까지 Rust로 → Burn
• LLM 서빙 빠르게 띄우기 → mistral.rs

13장 · Embassy — async embedded

Embassy는 임베디드 Rust의 async 표준이다. RTOS 없이, async/await로 인터럽트·DMA·timer를 다룬다. STM32 / nRF / RP2040 / ESP32(일부) HAL이 다 같이 진화한다.

#![no_std]
#![no_main]

use embassy_executor::Spawner;
use embassy_time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};

#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    let p = embassy_stm32::init(Default::default());
    let mut led = Output::new(p.PC13, Level::High, Speed::Low);
    loop {
        led.toggle();
        Timer::after(Duration::from_millis(500)).await;
    }
}

전통적인 임베디드 코드는 인터럽트 핸들러를 직접 짜고, "지금 어떤 상태?" 같은 state machine을 손으로 굴린다. Embassy는 그걸 async/await로 자연스럽게 표현한다 — Timer::after(...).await가 인터럽트 기반 sleep으로 컴파일된다.

핵심 패키지:

• embassy-executor — no_std async executor
• embassy-time — timer / delay
• embassy-net — TCP/IP (smoltcp 기반)
• embassy-stm32 / embassy-nrf / embassy-rp — HAL

14장 · 도구 — cargo-binstall / rust-analyzer / RustRover / Helix

14.1 cargo-binstall — 컴파일 없이 cargo 도구 설치

cargo install ripgrep 하면 ripgrep을 처음부터 빌드한다. 분 단위 시간 + 노트북 발열. cargo binstall ripgrep은 GitHub releases에서 미리 빌드된 바이너리를 가져온다.

cargo install cargo-binstall
cargo binstall ripgrep fd-find sd dust tokei cargo-watch cargo-edit

cargo 도구 절반은 이미 binstall 메타데이터를 제공한다. 평균 설치 시간이 30초 → 3초.

14.2 cargo-watch — 파일 바뀌면 다시 돈다

cargo binstall cargo-watch
cargo watch -x test
cargo watch -x run
cargo watch -x 'run --bin server'

Tauri / Leptos / Axum 개발 때 거의 모든 사람이 켜 둔다.

14.3 cargo-leptos — Leptos 전용 dev server

cargo leptos serve가 SSR 서버 + WASM 클라이언트 + 자산 핸들링을 하나로 묶는다. HMR도 된다 — Next.js dev server 비슷한 경험.

14.4 cargo-mobile2 — Rust 모바일 빌드

Dioxus / Tauri / 일반 Rust 라이브러리를 iOS/Android 타겟으로 빌드하는 wrapper. v1이 일부 중단됐다가 mobile2 fork가 사실상 표준이 됐다.

14.5 rust-analyzer — LSP

rust-analyzer는 Rust LSP의 사실상 표준이다. VS Code / Helix / Neovim / Zed 어디서든 첫 의존성이다. 2025년에 매크로 expansion 속도, async trait 추론, lifetime hint가 한층 좋아졌다.

14.6 RustRover — JetBrains 공식

JetBrains가 2023년에 IntelliJ-Rust를 RustRover로 정식 출시했다. 2024년 9월부터 비상업용 무료. 디버거 통합 / 프로파일러 / refactoring이 강하다.

14.7 Helix — Rust로 짠 modal editor

Helix는 Rust로 짜인 modal editor(neovim 스타일이지만 selection-first)다. 기본으로 LSP 통합, tree-sitter 기반 하이라이팅, 키바인딩이 vim과 다르다 (selection → action). 가벼움 / 빠른 부팅이 매력.

15장 · 한국 / 일본 — 카카오, 토스, 메르카리, ZOZO, Sansan

15.1 한국

• 카카오 — 일부 인프라/검색 서비스에서 Rust. 카카오엔터프라이즈가 Rust 발표를 종종 한다
• 토스 — Tossbank의 결제 인프라 일부에서 Rust 도입 사례 (gRPC 서버 / latency-critical path)
• 네이버 — Hyperscale AI 인프라에서 Rust 사용. NSML 일부 컴포넌트
• 삼성 — Tizen 일부, Galaxy 펌웨어 한 영역에서 Rust 검토

전체적으로는 "전사 도입"보다는 "특정 latency-critical 서비스 / 특정 인프라 컴포넌트"에서 부분 도입이 주류다.

15.2 일본

일본은 한국보다 Rust 도입이 한 박자 빠르다.

• メルカリ (Mercari) — Rust로 검색/추천 일부 마이그레이션. Tech Blog에 후기 다수
• ZOZO — ZOZOTOWN 일부 마이크로서비스에서 Rust. WebAssembly 활용 사례도
• Sansan — 명함 OCR / 데이터 처리 파이프라인의 핫 패스에 Rust
• CyberAgent — 광고 입찰 시스템 / 게임 백엔드 일부에서 Rust
• DeNA — 게임 / 차량 호출 일부 백엔드
• LINE (LY) — 메시징 / 미디어 처리 일부

특히 메르카리가 2022-2023년부터 꾸준히 Rust 케이스 스터디를 공개하면서, 일본 시니어 백엔드 시장에서 Rust 채용 공고가 눈에 띄게 늘었다.

16장 · 누가 Rust를 골라야 하나 — 시스템 / 임베디드 / 풀스택 / 게임

Rust는 만능 약이 아니다. 적합한 케이스가 있고, "굳이?" 싶은 케이스가 있다.

16.1 Rust가 빛나는 곳

• 시스템 프로그래밍 — kernel module, driver, OS, 가상화. Linux kernel이 Rust를 정식 받아들였다
• 임베디드 — Embassy + no_std로 RTOS 없이 async 임베디드
• 고성능 네트워크 서비스 — latency P99이 ms 단위로 중요할 때 (메시징, 결제, 광고 입찰)
• WebAssembly — wasm-pack / wasm-bindgen / trunk. 브라우저에서 무거운 계산
• CLI 도구 — ripgrep / fd / bat / dust / zoxide. 분배도 쉽고 빠르다
• 블록체인 / 암호 — Polkadot, Solana, foundry, reth
• 게임 (특히 인디) — Bevy ECS + 메모리 안전성

16.2 Rust가 부담인 곳

• CRUD 위주 사내 시스템 — Python/Go가 보통 더 빠르다 (개발 시간)
• 빠르게 prototype + 자주 destroy — borrow checker가 prototype 속도를 깎는다
• 데이터 분석 / ML 학습 자체 — Python 생태계가 압도적
• 간단한 스크립트 — Bash / Python / Deno로 충분한 영역
• 신입이 다수인 팀 — Rust 학습 곡선이 가파르다

16.3 2026년 Rust 학습 로드맵

1. The Rust Book (rust-lang.org/book) — 무조건 첫 책. 2024 edition 반영
2. Rust by Example — 코드 위주
3. Rustlings — 작은 연습 문제 100개+
4. Async Book — async/await 모델
5. Tokio Tutorial — Tokio가 어떻게 도는지
6. Axum 0.8 docs + 간단한 CRUD 만들기
7. (관심사 따라) Bevy / Tauri / Leptos / Embassy 중 하나로 토이 프로젝트

여기까지 오면, "Rust로 진짜 무언가를 만들 수 있는" 단계다. 평균 3-6개월. 빠르게 가고 싶으면 첫 토이 프로젝트를 가능한 빨리 시작한다 — 책만 읽으면 borrow checker는 못 이긴다.

17장 · 참고 / References

공식

• Rust
• The Rust Book (2024 edition)
• Rust 1.85 release notes
• Edition 2024 guide
• Async Book

웹 / 백엔드

• Tokio
• Axum
• Actix-Web
• Rocket
• Loco
• Tower

프론트엔드

• Leptos
• Dioxus
• Yew
• Trunk

DB

• sqlx
• Diesel
• SeaORM

게임 / 데스크탑 / 모바일

• Bevy
• Bevy 0.15 release notes
• Tauri
• Tauri v2
• cargo-mobile2

ML

• Burn
• Candle
• mistral.rs

임베디드

• Embassy
• Embedded Rust Book

도구 / IDE

• cargo-binstall
• cargo-watch
• cargo-leptos
• rust-analyzer
• RustRover
• Helix

한국 / 일본 케이스

• Mercari Engineering Blog (Rust)
• ZOZO TECH BLOG (Rust)
• CyberAgent Developers Blog
• Kakao Tech (Korean)
• Toss Tech