Rust in 2025: 45.5% Adoption, TIOBE #13, Linux Kernel — Should Your Team Learn Rust?

Organizational Adoption:  45.5% (+17.6% YoY)
Primary Language Use:     38.2%
Commercial Use:           68.75% growth (vs. 2021)
TIOBE Ranking:            #13 (all-time high)
Stack Overflow:           9 consecutive years "Most Admired Language"
crates.io Packages:       150,000+ (as of late 2024)

Year-over-Year Organizational Adoption:
2020: ~15%
2021: ~20%
2022: ~25%
2023: 27.9%
2024: 34.8%
2025: 45.5%

// Traditional Linux kernel driver (C language)
// Risk of NULL pointer, buffer overflow and other memory bugs
static int my_driver_probe(struct platform_device *pdev) {
    struct my_data *data;
    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
    if (!data)
        return -ENOMEM;
    // ... manual memory management
}

// Kernel driver written in Rust
// Memory safety guaranteed at compile time
use kernel::prelude::*;

module! {
    type: MyDriver,
    name: "my_driver",
    license: "GPL",
}

struct MyDriver {
    // Ownership system ensures memory safety
}

impl kernel::Module for MyDriver {
    fn init(_module: &'static ThisModule) -> Result<Self> {
        pr_info!("Rust driver loaded\n");
        Ok(MyDriver {})
    }
}

Firecracker:   Micro VM for serverless workloads (powers Lambda, Fargate)
Bottlerocket:  Container-focused Linux-based OS
S2N-TLS:       TLS protocol implementation
Mountpoint:    File system client for S3
Cedar:         Authorization policy language and engine

Service: Read States (read status tracking)
Problem: Latency spikes caused by Go's GC (Garbage Collector)
Result:  After Go -> Rust migration:
         - P99 latency improved by 10x
         - Significant reduction in memory usage
         - GC-related latency spikes completely eliminated

1Password:    Core password management logic
Figma:        Multiplayer server
Vercel:       Turbopack (next-generation bundler)
Shopify:      YJIT (Ruby JIT compiler, written in Rust)
npm:          Parts of registry infrastructure

- Rapid development speed is the top priority
- Building microservices / API servers
- DevOps tooling (Kubernetes ecosystem)
- Team onboarding speed matters
- Prototyping with quick releases

- Extreme performance is needed (P99 latency matters)
- Memory safety directly impacts security
- Systems programming (kernel, drivers)
- Predictable performance without GC
- Embedded / resource-constrained environments

// Rust: Compiler guarantees memory safety
fn process_data(data: &[u8]) -> Vec<u8> {
    let mut result = Vec::new();
    for &byte in data {
        if byte > 0 {
            result.push(byte * 2);
        }
    }
    result
    // Memory for result is automatically freed when going out of scope
}

// C++: Developer manually manages memory
std::vector<uint8_t> process_data(const uint8_t* data, size_t len) {
    std::vector<uint8_t> result;
    for (size_t i = 0; i < len; ++i) {
        if (data[i] > 0) {
            result.push_back(data[i] * 2);
        }
    }
    return result;
    // Could data be a dangling pointer? Compiler doesn't verify
}

Java's Strengths:
- Enterprise ecosystem (Spring, Jakarta EE)
- Vast libraries
- JVM optimizations (HotSpot)
- Abundant talent pool

Rust's Advantages (vs Java):
- Predictable latency without GC
- Much smaller binary / memory footprint
- Native compilation
- System-level access

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // Ownership of s1 moves to s2
    // println!("{}", s1); // Compile error! s1 is no longer valid
    println!("{}", s2); // OK
}

fn main() {
    let s1 = String::from("hello");

    // Immutable borrow: multiple allowed
    let len = calculate_length(&s1);
    println!("'{}' length: {}", s1, len); // s1 still usable

    // Mutable borrow: only one at a time
    let mut s2 = String::from("hello");
    change(&mut s2);
    println!("{}", s2); // "hello, world"
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

fn change(s: &mut String) {
    s.push_str(", world");
}

// When lifetime annotations are needed
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("long string");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
        println!("Longest string: {}", result);
    }
    // Using result here would cause an error (string2 already freed)
}

// Enums and pattern matching
enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
    Triangle(f64, f64, f64),
}

fn area(shape: &Shape) -> f64 {
    match shape {
        Shape::Circle(r) => std::f64::consts::PI * r * r,
        Shape::Rectangle(w, h) => w * h,
        Shape::Triangle(a, b, c) => {
            let s = (a + b + c) / 2.0;
            (s * (s - a) * (s - b) * (s - c)).sqrt()
        }
    }
}

// Error handling: Result and Option
fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10.0, 3.0) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }

    // Concise with the ? operator
    let result = divide(10.0, 0.0).unwrap_or(0.0);
    println!("With default: {}", result);
}

// Trait definition and implementation
trait Summarizable {
    fn summary(&self) -> String;

    // Default implementation possible
    fn preview(&self) -> String {
        format!("{}...", &self.summary()[..20])
    }
}

struct Article {
    title: String,
    content: String,
}

impl Summarizable for Article {
    fn summary(&self) -> String {
        format!("{}: {}", self.title, &self.content[..50])
    }
}

// Generics and trait bounds
fn print_summary<T: Summarizable>(item: &T) {
    println!("{}", item.summary());
}

// Iterators and closures
fn process_numbers(numbers: Vec<i32>) -> Vec<i32> {
    numbers
        .iter()
        .filter(|&&n| n > 0)
        .map(|&n| n * 2)
        .collect()
}

// Axum web server example
use axum::{routing::get, Router, Json};
use serde::Serialize;

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

async fn get_user() -> Json<User> {
    Json(User {
        id: 1,
        name: "Alice".to_string(),
    })
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/user", get(get_user));

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

# Cargo.toml dependencies
[dependencies]
axum = "0.7"
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

// unsafe block: use only when necessary
unsafe fn dangerous() {
    // Raw pointer dereferencing, etc.
}

// FFI: Calling C libraries
extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    let result = unsafe { abs(-5) };
    println!("Absolute value: {}", result);
}

// Declarative macros
macro_rules! vec_of_strings {
    ($($x:expr),*) => {
        vec![$($x.to_string()),*]
    };
}

fn demo() {
    let names = vec_of_strings!["Alice", "Bob", "Charlie"];
    println!("{:?}", names);
}

Free Resources:
1. The Rust Programming Language (Official Book)
   - https://doc.rust-lang.org/book/
   - The most systematic introduction

2. Rustlings (Interactive Exercises)
   - https://github.com/rust-lang/rustlings
   - Learn by solving small problems

3. Rust by Example
   - https://doc.rust-lang.org/rust-by-example/
   - Example-driven learning

4. 100 Exercises To Learn Rust
   - https://rust-exercises.com/
   - Free course released in 2024

5. Comprehensive Rust (Google)
   - https://google.github.io/comprehensive-rust/
   - Google's internal training material, open-sourced

Paid/Advanced Resources:
6. Programming Rust, 2nd Edition (O'Reilly)
7. Rust in Action (Manning)
8. Zero To Production In Rust (web backend focused)

Estimated learning period by background:
- C/C++ developer:       2-3 months (quick to grasp memory model)
- Go developer:          3-4 months (needs to adapt to ownership)
- Java/C# developer:     4-5 months (adapting to GC-free environment)
- Python/JS developer:   5-6 months (systems programming + ownership)
- First programming language: Not recommended (learn another first)

Key Concerns (2025 Survey):
1. Growing complexity:        41.6%
2. Insufficient adoption:     42.1%
3. Learning curve:            (top complaint)
4. Compile times:             (persistent issue)
5. Incomplete tooling:        (IDE, debugger)

// Showing why Rust's async is complex
// Unlike other languages, async function return types can be complicated
use std::future::Future;

fn make_request(url: &str) -> impl Future<Output = Result<String, reqwest::Error>> + '_ {
    async move {
        let response = reqwest::get(url).await?;
        response.text().await
    }
}

Approximate compile times by project size (clean build):
- Small (10K lines):     10-30 seconds
- Medium (100K lines):   2-5 minutes
- Large (500K+ lines):   10-30 minutes

Mitigation strategies:
- Use cargo check (type checking only, skips code generation)
- Cache with sccache
- Split workspaces
- Leverage incremental compilation
- Use cranelift backend (debug builds)

Mature Areas:
- Web frameworks (Axum, Actix)
- Serialization (serde)
- HTTP client (reqwest)
- CLI tools (clap)
- Async runtime (tokio)

Growing Areas:
- GUI (iced, egui - still early)
- ORM (diesel, sea-orm - evolving)
- Enterprise patterns (no unified framework like Spring)
- Machine learning (burn, candle - early stage)

Rust Developer Market:
- Demand: Surging (especially in infrastructure, security)
- Supply: Limited (small fraction of total developers)
- Average Salary: Upper tier (approximately 120-180K USD)
- Implication: Learning it boosts competitiveness, but team building is difficult

1. Start at the FFI Boundary
   - Connect existing code with Rust via FFI
   - Convert the riskiest parts (memory safety issues) to Rust first
   - Start with performance-critical hot paths

2. Write New Services in Rust
   - Keep existing code as-is
   - Start new microservices in Rust
   - Gradually expand the Rust footprint

3. Strangler Fig Pattern
   - Build a new Rust layer wrapping the existing system
   - Gradually shift traffic to the new layer
   - Incrementally retire the old system

When to Migrate:
- GC-related latency spikes impact business
- P99 latency requirements are very strict
- Memory usage optimization is essential
- Repeated outages due to concurrency bugs

When NOT to Migrate:
- Go's performance is sufficient
- Team has zero Rust experience
- Rapid development speed is the top priority
- CRUD-centric business logic

// Go to Rust: HTTP Handler Comparison

// Go version (pseudocode for reference)
// func getUser(w http.ResponseWriter, r *http.Request) {
//     id := r.URL.Query().Get("id")
//     user, err := db.FindUser(id)
//     if err != nil {
//         http.Error(w, err.Error(), 500)
//         return
//     }
//     json.NewEncoder(w).Encode(user)
// }

// Rust (Axum) version
use axum::{extract::Query, Json};
use serde::Deserialize;

#[derive(Deserialize)]
struct UserQuery {
    id: String,
}

async fn get_user(Query(params): Query<UserQuery>) -> Result<Json<User>, AppError> {
    let user = db::find_user(&params.id).await?;
    Ok(Json(user))
}

Step-by-Step Approach:
Step 1: Write new modules in Rust, connect via C++ FFI
Step 2: Establish test coverage (existing C++ code)
Step 3: Port the riskiest modules to Rust first
Step 4: Verify behavior with integration tests
Step 5: Gradually expand

FFI Tools:
- cxx: Safe FFI between C++ and Rust
- bindgen: Auto-generate Rust bindings from C/C++ headers
- cbindgen: Generate C/C++ headers from Rust

// Example of C++ interop using cxx
#[cxx::bridge]
mod ffi {
    // Functions provided by the C++ side
    unsafe extern "C++" {
        include!("legacy/include/processor.h");
        fn process_legacy_data(input: &[u8]) -> Vec<u8>;
    }

    // Functions provided by the Rust side
    extern "Rust" {
        fn validate_data(data: &[u8]) -> bool;
    }
}

fn validate_data(data: &[u8]) -> bool {
    // Safe validation logic in Rust
    !data.is_empty() && data.len() < 1_000_000
}

Preparation:
[ ] Secure 1-2 Rust champions within the team
[ ] Build experience with a pilot project (2-3 months)
[ ] Measure performance baselines of the current system
[ ] Prioritize modules for migration
[ ] Add Rust build to CI/CD pipeline

Execution:
[ ] Design FFI interfaces
[ ] Write unit tests (Rust side)
[ ] Maintain integration tests (existing test suite)
[ ] Gradually shift traffic
[ ] Monitor and compare performance

Post-Migration:
[ ] Measure and document performance improvements
[ ] Create team training materials
[ ] Select next migration target

Axum (developed by the tokio team):
- Perfect integration with the tokio ecosystem
- Tower middleware compatibility
- Type-safe routing
- Fastest growing Rust web framework in 2024-2025

Actix Web:
- Top-tier benchmark performance
- Mature ecosystem
- Multiple enterprise use cases

Loco.rs:
- Rails-style all-in-one framework
- Emerged in 2024, growing rapidly
- Focused on developer productivity

Bevy:
- Data-oriented game engine
- ECS (Entity Component System) architecture
- Rapidly growing community
- Not yet 1.0 but highly promising

wgpu:
- WebGPU implementation
- Cross-platform GPU programming
- Used in Firefox

Tauri:
- Electron alternative
- Web technologies (HTML/CSS/JS) + Rust backend
- Much smaller binary size (10-100x smaller than Electron)
- Significant memory usage reduction
- v2.0 released with mobile support

Dioxus:
- React-style Rust UI framework
- Web, desktop, and mobile support

// Rust -> WASM example (using wasm-bindgen)
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn fibonacci(n: u32) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => {
            let mut a: u64 = 0;
            let mut b: u64 = 1;
            for _ in 2..=n {
                let temp = b;
                b = a + b;
                a = temp;
            }
            b
        }
    }
}

// Called from JavaScript:
// import { fibonacci } from './pkg/my_wasm';
// console.log(fibonacci(50));

Rust + WASM Use Cases:
- Figma: Core logic of the real-time collaborative editor
- Cloudflare Workers: Edge computing
- 1Password: Browser extension
- Amazon Prime Video: Video processing
- AutoCAD: Rendering engine for the web version

burn:
- PyTorch-style deep learning framework
- Multiple backend support (GPU, CPU, WASM)
- Pure Rust implementation

candle (Hugging Face):
- Lightweight ML inference framework
- Specialized for LLM inference
- Run ML models without Python dependencies

ort:
- Rust bindings for ONNX Runtime
- Suitable for production deployment of trained models
- Various hardware acceleration support

linfa:
- scikit-learn style traditional ML library
- Clustering, classification, regression, etc.

Legacy Tool -> Rust Replacement:
grep     -> ripgrep (rg)
find     -> fd
cat      -> bat
ls       -> exa/eza
du       -> dust
top      -> bottom (btm)
sed      -> sd
curl     -> xh
diff     -> delta

CLI Libraries:
- clap: Command-line argument parsing (de facto standard)
- ratatui: TUI (Terminal UI) framework
- indicatif: Progress bars
- dialoguer: Interactive prompts

embassy:
- Async embedded framework
- async/await support in no_std environments
- Support for STM32, nRF, RP2040, and various MCUs

esp-rs:
- Rust support for ESP32 family MCUs
- Includes WiFi and Bluetooth

probe-rs:
- Debugging/flashing tool
- ARM and RISC-V support