Rust in Industry: Case Studies and Success Stories in 2025

// Example of a Windows component written in Rust
use windows::{
    core::*,
    Win32::Foundation::*,
    Win32::System::Threading::*,
    Win32::Security::*,
};

struct SecurityMonitor {
    // Component state
}

impl SecurityMonitor {
    fn new() -> Result<Self> {
        // Initialize with appropriate Windows API calls
        // ...
        Ok(SecurityMonitor { /* ... */ })
    }
    
    fn check_process_integrity(&self, process_id: u32) -> Result<IntegrityLevel> {
        unsafe {
            let process_handle = OpenProcess(
                PROCESS_QUERY_LIMITED_INFORMATION,
                false,
                process_id,
            )?;
            
            // Get the process token
            let mut token_handle = HANDLE::default();
            if !OpenProcessToken(
                process_handle,
                TOKEN_QUERY,
                &mut token_handle,
            ).as_bool() {
                return Err(Error::from_win32());
            }
            
            // Check integrity level
            // ...
            
            Ok(IntegrityLevel::Medium) // Example return
        }
    }
}

enum IntegrityLevel {
    Low,
    Medium,
    High,
    System,
}

// Example of Android component written in Rust
use jni::{JNIEnv, objects::JObject, sys::jint};
use android_logger::Config;

#[no_mangle]
pub extern "system" fn Java_com_example_RustBridge_initializeSecurityMonitor(
    env: JNIEnv,
    _class: JObject,
    config_path: JObject,
) -> jint {
    // Set up logging
    android_logger::init_once(
        Config::default()
            .with_min_level(log::Level::Info)
            .with_tag("RustSecurityMonitor"),
    );
    
    // Convert Java string to Rust string
    let config_path: String = env.get_string(config_path.into())
        .expect("Invalid config path string")
        .into();
    
    log::info!("Initializing security monitor with config: {}", config_path);
    
    // Initialize the security monitor
    match initialize_security_monitor(&config_path) {
        Ok(_) => 0, // Success
        Err(e) => {
            log::error!("Failed to initialize security monitor: {}", e);
            -1 // Error
        }
    }
}

fn initialize_security_monitor(config_path: &str) -> Result<(), Box<dyn std::error::Error>> {
    // Implementation
    Ok(())
}

// Example of AWS Lambda runtime component in Rust
use lambda_runtime::{service_fn, Error, LambdaEvent};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::sync::Mutex;

#[derive(Deserialize)]
struct Request {
    function_name: String,
    payload: serde_json::Value,
}

#[derive(Serialize)]
struct Response {
    result: String,
    metrics: ExecutionMetrics,
}

#[derive(Serialize)]
struct ExecutionMetrics {
    duration_ms: u64,
    memory_used_mb: u64,
    cpu_usage_percent: f64,
}

struct FunctionExecutor {
    // State for executing functions
}

impl FunctionExecutor {
    async fn execute(&self, request: Request) -> Result<Response, Error> {
        // Function execution logic
        Ok(Response {
            result: "Success".to_string(),
            metrics: ExecutionMetrics {
                duration_ms: 42,
                memory_used_mb: 128,
                cpu_usage_percent: 22.5,
            },
        })
    }
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    // Initialize the function executor
    let executor = Arc::new(Mutex::new(FunctionExecutor { /* ... */ }));
    
    // Define the handler function
    let handler_func = service_fn(|event: LambdaEvent<Request>| {
        let executor = executor.clone();
        async move {
            let request = event.payload;
            let executor = executor.lock().await;
            executor.execute(request).await
        }
    });
    
    // Start the Lambda runtime
    lambda_runtime::run(handler_func).await?;
    
    Ok(())
}

// Example of WebRender component
use euclid::{Point2D, Rect, Size2D};
use webrender_api::{ColorF, DisplayListBuilder, RenderApi};

struct RenderTask {
    bounds: Rect<i32, i32>,
    content_type: ContentType,
}

enum ContentType {
    Solid(ColorF),
    Image(ImageKey),
    Text(Vec<GlyphInstance>),
}

impl RenderTask {
    fn new(bounds: Rect<i32, i32>, content_type: ContentType) -> Self {
        RenderTask { bounds, content_type }
    }
    
    fn build_display_list(&self, builder: &mut DisplayListBuilder) {
        match &self.content_type {
            ContentType::Solid(color) => {
                builder.push_rect(
                    &CommonItemProperties::new(self.bounds),
                    self.bounds,
                    *color,
                );
            }
            ContentType::Image(key) => {
                builder.push_image(
                    &CommonItemProperties::new(self.bounds),
                    self.bounds,
                    ImageRendering::Auto,
                    AlphaType::PremultipliedAlpha,
                    *key,
                    ColorF::WHITE,
                );
            }
            ContentType::Text(glyphs) => {
                // Text rendering logic
            }
        }
    }
}

// Example of trading system component
use chrono::{DateTime, Utc};
use rust_decimal::Decimal;
use std::sync::Arc;

#[derive(Clone, Debug)]
struct Order {
    id: String,
    symbol: String,
    side: OrderSide,
    quantity: Decimal,
    price: Decimal,
    timestamp: DateTime<Utc>,
}

#[derive(Clone, Copy, Debug)]
enum OrderSide {
    Buy,
    Sell,
}

struct OrderBook {
    symbol: String,
    bids: Vec<PriceLevel>,
    asks: Vec<PriceLevel>,
}

struct PriceLevel {
    price: Decimal,
    quantity: Decimal,
    order_count: usize,
}

impl OrderBook {
    fn new(symbol: &str) -> Self {
        OrderBook {
            symbol: symbol.to_string(),
            bids: Vec::new(),
            asks: Vec::new(),
        }
    }
    
    fn process_order(&mut self, order: &Order) -> OrderResult {
        match order.side {
            OrderSide::Buy => self.process_buy_order(order),
            OrderSide::Sell => self.process_sell_order(order),
        }
    }
    
    fn process_buy_order(&mut self, order: &Order) -> OrderResult {
        // Implementation of buy order processing
        OrderResult::Filled
    }
    
    fn process_sell_order(&mut self, order: &Order) -> OrderResult {
        // Implementation of sell order processing
        OrderResult::Filled
    }
}

enum OrderResult {
    Filled,
    PartiallyFilled(Decimal),
    Rejected(String),
}

// Example of network management component
use tokio::sync::{mpsc, Mutex};
use std::collections::HashMap;
use std::sync::Arc;

struct NetworkNode {
    id: String,
    node_type: NodeType,
    status: NodeStatus,
    connections: Vec<String>,
    metrics: NodeMetrics,
}

enum NodeType {
    CoreRouter,
    EdgeRouter,
    BaseStation,
    Antenna,
}

enum NodeStatus {
    Online,
    Degraded,
    Offline,
    Maintenance,
}

struct NodeMetrics {
    cpu_usage: f64,
    memory_usage: f64,
    network_throughput: u64,
    active_connections: u32,
}

struct NetworkManager {
    nodes: HashMap<String, NetworkNode>,
    alerts_tx: mpsc::Sender<Alert>,
}

struct Alert {
    node_id: String,
    severity: AlertSeverity,
    message: String,
    timestamp: chrono::DateTime<chrono::Utc>,
}

enum AlertSeverity {
    Info,
    Warning,
    Critical,
    Emergency,
}

impl NetworkManager {
    async fn monitor_network(&mut self) {
        for (id, node) in &mut self.nodes {
            if let Err(e) = self.update_node_status(id).await {
                self.send_alert(Alert {
                    node_id: id.clone(),
                    severity: AlertSeverity::Warning,
                    message: format!("Failed to update node status: {}", e),
                    timestamp: chrono::Utc::now(),
                }).await;
            }
        }
    }
    
    async fn update_node_status(&mut self, node_id: &str) -> Result<(), NetworkError> {
        // Implementation
        Ok(())
    }
    
    async fn send_alert(&self, alert: Alert) {
        if let Err(e) = self.alerts_tx.send(alert).await {
            eprintln!("Failed to send alert: {}", e);
        }
    }
}

#[derive(Debug)]
enum NetworkError {
    ConnectionFailed(String),
    Timeout(String),
    AuthenticationFailed,
    InternalError(String),
}

// Example of blockchain transaction processor
use sha2::{Digest, Sha256};
use ed25519_dalek::{Keypair, PublicKey, Signature, Signer, Verifier};
use serde::{Deserialize, Serialize};

#[derive(Clone, Debug, Serialize, Deserialize)]
struct Transaction {
    id: String,
    from: String,
    to: String,
    amount: u64,
    fee: u64,
    timestamp: u64,
    signature: Vec<u8>,
}

impl Transaction {
    fn new(from: &str, to: &str, amount: u64, fee: u64, keypair: &Keypair) -> Self {
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();
        
        let mut tx = Transaction {
            id: String::new(),
            from: from.to_string(),
            to: to.to_string(),
            amount,
            fee,
            timestamp,
            signature: Vec::new(),
        };
        
        // Generate transaction ID
        let mut hasher = Sha256::new();
        hasher.update(format!("{}{}{}{}{}", from, to, amount, fee, timestamp));
        tx.id = format!("{:x}", hasher.finalize());
        
        // Sign the transaction
        let message = tx.id.as_bytes();
        tx.signature = keypair.sign(message).to_bytes().to_vec();
        
        tx
    }
    
    fn verify(&self, public_key: &PublicKey) -> bool {
        let message = self.id.as_bytes();
        let signature = match Signature::from_bytes(&self.signature[..]) {
            Ok(sig) => sig,
            Err(_) => return false,
        };
        
        public_key.verify(message, &signature).is_ok()
    }
}

// Example of medical data processing system
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Clone, Debug, Serialize, Deserialize)]
struct Patient {
    id: String,
    name: String,
    date_of_birth: DateTime<Utc>,
    medical_records: Vec<MedicalRecord>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
struct MedicalRecord {
    id: String,
    patient_id: String,
    doctor_id: String,
    timestamp: DateTime<Utc>,
    record_type: RecordType,
    data: RecordData,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
enum RecordType {
    Examination,
    LabResult,
    Prescription,
    Surgery,
    Imaging,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
struct RecordData {
    fields: HashMap<String, String>,
    attachments: Vec<Attachment>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
struct Attachment {
    id: String,
    name: String,
    content_type: String,
    size: usize,
    hash: String,
}

// Example of Rust interoperability with C++
use std::ffi::{CStr, CString};
use std::os::raw::{c_char, c_int};

// FFI interface for C++ code to call
#[no_mangle]
pub extern "C" fn process_data_from_cpp(
    input: *const c_char,
    length: c_int,
) -> *mut c_char {
    // Convert C string to Rust string
    let c_str = unsafe {
        if input.is_null() {
            return std::ptr::null_mut();
        }
        CStr::from_ptr(input)
    };
    
    let input_str = match c_str.to_str() {
        Ok(s) => s,
        Err(_) => return std::ptr::null_mut(),
    };
    
    // Process the data in Rust
    let result = format!("Processed: {}", input_str);
    
    // Convert back to C string
    let output = match CString::new(result) {
        Ok(s) => s,
        Err(_) => return std::ptr::null_mut(),
    };
    
    // Transfer ownership to the caller
    output.into_raw()
}

// Function to free memory allocated by Rust
#[no_mangle]
pub extern "C" fn free_string(ptr: *mut c_char) {
    unsafe {
        if !ptr.is_null() {
            let _ = CString::from_raw(ptr);
        }
    }
}

// Example of performance optimization in Rust
use rayon::prelude::*;

fn process_data_parallel(data: &[u64]) -> Vec<u64> {
    data.par_iter()
        .map(|&x| {
            // Expensive computation
            let mut result = x;
            for _ in 0..1000 {
                result = (result * 0x7FFF_FFFF) % 0xFFFF_FFFF;
            }
            result
        })
        .collect()
}

fn benchmark() {
    let large_data: Vec<u64> = (0..100_000).collect();
    
    // Sequential processing
    let start = std::time::Instant::now();
    let result1 = large_data.iter().map(|&x| {
        // Same computation as above
        let mut result = x;
        for _ in 0..1000 {
            result = (result * 0x7FFF_FFFF) % 0xFFFF_FFFF;
        }
        result
    }).collect::<Vec<_>>();
    let sequential_time = start.elapsed();
    
    // Parallel processing
    let start = std::time::Instant::now();
    let result2 = process_data_parallel(&large_data);
    let parallel_time = start.elapsed();
    
    println!("Sequential: {:?}", sequential_time);
    println!("Parallel: {:?}", parallel_time);
    println!("Speedup: {:.2}x", sequential_time.as_secs_f64() / parallel_time.as_secs_f64());
}