필사 모드: 모던 Rust 2026 — Rust 1.85 / Edition 2024 / Tokio / Axum 0.8 / Loco / Leptos / Bevy / Tauri 2 / Embassy 심층 가이드
한국어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! {
"Count: " {count}
}
}
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:
| 항목 | Tauri 2 | Electron |
| --- | --- | --- |
| 백엔드 언어 | Rust | Node.js |
| webview | OS native | Chromium 번들 |
| 바이너리 크기 | ~3-10 MB | ~80-150 MB |
| 메모리 | ~50-100 MB | ~150-400 MB |
| 모바일 | iOS/Android | X |
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](https://www.rust-lang.org/)
- [The Rust Book (2024 edition)](https://doc.rust-lang.org/book/)
- [Rust 1.85 release notes](https://blog.rust-lang.org/2025/02/20/Rust-1.85.0/)
- [Edition 2024 guide](https://doc.rust-lang.org/edition-guide/rust-2024/index.html)
- [Async Book](https://rust-lang.github.io/async-book/)
웹 / 백엔드
- [Tokio](https://tokio.rs/)
- [Axum](https://github.com/tokio-rs/axum)
- [Actix-Web](https://actix.rs/)
- [Rocket](https://rocket.rs/)
- [Loco](https://loco.rs/)
- [Tower](https://github.com/tower-rs/tower)
프론트엔드
- [Leptos](https://leptos.dev/)
- [Dioxus](https://dioxuslabs.com/)
- [Yew](https://yew.rs/)
- [Trunk](https://trunkrs.dev/)
DB
- [sqlx](https://github.com/launchbadge/sqlx)
- [Diesel](https://diesel.rs/)
- [SeaORM](https://www.sea-ql.org/SeaORM/)
게임 / 데스크탑 / 모바일
- [Bevy](https://bevyengine.org/)
- [Bevy 0.15 release notes](https://bevyengine.org/news/bevy-0-15/)
- [Tauri](https://tauri.app/)
- [Tauri v2](https://v2.tauri.app/)
- [cargo-mobile2](https://github.com/tauri-apps/cargo-mobile2)
ML
- [Burn](https://burn.dev/)
- [Candle](https://github.com/huggingface/candle)
- [mistral.rs](https://github.com/EricLBuehler/mistral.rs)
임베디드
- [Embassy](https://embassy.dev/)
- [Embedded Rust Book](https://docs.rust-embedded.org/book/)
도구 / IDE
- [cargo-binstall](https://github.com/cargo-bins/cargo-binstall)
- [cargo-watch](https://github.com/watchexec/cargo-watch)
- [cargo-leptos](https://github.com/leptos-rs/cargo-leptos)
- [rust-analyzer](https://rust-analyzer.github.io/)
- [RustRover](https://www.jetbrains.com/rust/)
- [Helix](https://helix-editor.com/)
한국 / 일본 케이스
- [Mercari Engineering Blog (Rust)](https://engineering.mercari.com/blog/tags/rust/)
- [ZOZO TECH BLOG (Rust)](https://techblog.zozo.com/archive/category/Rust)
- [CyberAgent Developers Blog](https://developers.cyberagent.co.jp/blog/)
- [Kakao Tech (Korean)](https://tech.kakao.com/)
- [Toss Tech](https://toss.tech/)
현재 단락 (1/373)
2025년 2월 20일, Rust 1.85가 풀렸다. 그리고 그 날, **2024 edition**이 새 프로젝트의 기본값이 되었다. Rust edition은 3년 주기로 돌아오는...