The Rust Ecosystem and Community in 2025: A Comprehensive Guide

// serde: Serialization/deserialization framework
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
struct Person {
    name: String,
    age: u32,
    emails: Vec<String>,
}

fn main() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
        emails: vec!["[email protected]".to_string()],
    };
    
    // Serialize to JSON
    let json = serde_json::to_string_pretty(&person).unwrap();
    println!("{}", json);
    
    // Deserialize from JSON
    let deserialized: Person = serde_json::from_str(&json).unwrap();
    println!("{:?}", deserialized);
}

// rand: Random number generation
use rand::prelude::*;

fn main() {
    // Generate a random number between 1 and 100
    let random_number: u32 = thread_rng().gen_range(1..=100);
    println!("Random number: {}", random_number);
    
    // Generate a random boolean
    let random_bool: bool = random();
    println!("Random boolean: {}", random_bool);
    
    // Shuffle a vector
    let mut numbers = vec![1, 2, 3, 4, 5];
    numbers.shuffle(&mut thread_rng());
    println!("Shuffled numbers: {:?}", numbers);
}

// chrono: Date and time handling
use chrono::{DateTime, Utc, TimeZone, Duration};

fn main() {
    // Current UTC time
    let now: DateTime<Utc> = Utc::now();
    println!("Current UTC time: {}", now);
    
    // Parse a date string
    let date = Utc.with_ymd_and_hms(2025, 10, 15, 8, 0, 0).unwrap();
    println!("Parsed date: {}", date);
    
    // Add duration
    let future = now + Duration::days(7);
    println!("One week from now: {}", future);
}

// tokio: Async runtime
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    println!("Starting...");
    
    // Spawn a task
    let task = tokio::spawn(async {
        sleep(Duration::from_secs(1)).await;
        println!("Task completed");
        "Task result"
    });
    
    // Wait for the task to complete
    let result = task.await.unwrap();
    println!("Result: {}", result);
}

// reqwest: HTTP client
use reqwest::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    
    // Make a GET request
    let response = client.get("https://api.example.com/data")
        .header("User-Agent", "Rust App")
        .send()
        .await?;
    
    // Check if the request was successful
    if response.status().is_success() {
        let body = response.text().await?;
        println!("Response: {}", body);
    } else {
        println!("Error: {}", response.status());
    }
    
    Ok(())
}

// axum: Web framework
use axum::{
    routing::{get, post},
    Router, Json, extract::Path,
};
use serde::{Deserialize, Serialize};

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

async fn get_user(Path(id): Path<u64>) -> Json<User> {
    Json(User {
        id,
        name: format!("User {}", id),
    })
}

async fn create_user(Json(user): Json<User>) -> Json<User> {
    println!("Created user: {}", user.name);
    Json(user)
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/users/:id", get(get_user))
        .route("/users", post(create_user));
    
    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}

// sqlx: Async SQL database access
use sqlx::{postgres::PgPoolOptions, Row};

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    // Create a connection pool
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect("postgres://postgres:password@localhost/test").await?;
    
    // Execute a query
    let rows = sqlx::query("SELECT id, name FROM users WHERE active = $1")
        .bind(true)
        .fetch_all(&pool)
        .await?;
    
    // Process the results
    for row in rows {
        let id: i32 = row.get("id");
        let name: String = row.get("name");
        println!("User {}: {}", id, name);
    }
    
    Ok(())
}

// diesel: ORM and query builder
use diesel::prelude::*;
use diesel::pg::PgConnection;
use dotenvy::dotenv;
use std::env;

// Define the schema
table! {
    users (id) {
        id -> Integer,
        name -> Text,
        email -> Text,
        active -> Bool,
    }
}

// Define the model
#[derive(Queryable, Selectable)]
#[diesel(table_name = users)]
struct User {
    id: i32,
    name: String,
    email: String,
    active: bool,
}

fn main() {
    dotenv().ok();
    
    let database_url = env::var("DATABASE_URL")
        .expect("DATABASE_URL must be set");
    let mut conn = PgConnection::establish(&database_url)
        .expect("Error connecting to database");
    
    // Query active users
    let results = users::table
        .filter(users::active.eq(true))
        .limit(5)
        .select(User::as_select())
        .load(&mut conn)
        .expect("Error loading users");
    
    println!("Displaying {} users", results.len());
    for user in results {
        println!("{}: {} ({})", user.id, user.name, user.email);
    }
}

// clap: Command line argument parsing
use clap::{Parser, Subcommand};

#[derive(Parser)]
#[command(name = "mycli")]
#[command(about = "A CLI application", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
    
    #[arg(short, long, global = true)]
    verbose: bool,
}

#[derive(Subcommand)]
enum Commands {
    /// Add a new item
    Add {
        /// Name of the item
        name: String,
        
        /// Value of the item
        #[arg(short, long)]
        value: Option<String>,
    },
    
    /// Remove an item
    Remove {
        /// Name of the item
        name: String,
    },
}

fn main() {
    let cli = Cli::parse();
    
    if cli.verbose {
        println!("Verbose mode enabled");
    }
    
    match &cli.command {
        Commands::Add { name, value } => {
            println!("Adding item: {}", name);
            if let Some(value) = value {
                println!("With value: {}", value);
            }
        }
        Commands::Remove { name } => {
            println!("Removing item: {}", name);
        }
    }
}

// indicatif: Progress bars and indicators
use indicatif::{ProgressBar, ProgressStyle};
use std::{thread, time::Duration};

fn main() {
    let pb = ProgressBar::new(100);
    pb.set_style(ProgressStyle::default_bar()
        .template("{spinner:.green} [{elapsed_precise}] [{bar:40.cyan/blue}] {pos}/{len} ({eta})")
        .unwrap()
        .progress_chars("#>-"));
    
    for i in 0..100 {
        pb.inc(1);
        thread::sleep(Duration::from_millis(50));
    }
    
    pb.finish_with_message("done");
}

# cargo-edit: Add, remove, and upgrade dependencies
cargo install cargo-edit
cargo add serde --features derive
cargo rm unused-dependency
cargo upgrade

# cargo-watch: Watch for changes and run commands
cargo install cargo-watch
cargo watch -x 'run --example demo'

# cargo-expand: Show expanded macros
cargo install cargo-expand
cargo expand

# cargo-audit: Audit dependencies for vulnerabilities
cargo install cargo-audit
cargo audit

# cargo-bloat: Find what takes most space in your executable
cargo install cargo-bloat
cargo bloat --release

# cargo-flamegraph: Profiling with flamegraphs
cargo install flamegraph
cargo flamegraph

# rust-analyzer: Language server for IDE integration
rustup component add rust-analyzer

# VS Code setup (settings.json)
{
    "rust-analyzer.checkOnSave.command": "clippy",
    "rust-analyzer.procMacro.enable": true,
    "rust-analyzer.cargo.allFeatures": true,
    "editor.formatOnSave": true
}

# IntelliJ/CLion setup
# Install the "Rust" plugin from JetBrains Marketplace
# Configure Rust toolchain in Settings > Languages & Frameworks > Rust

# rustfmt: Code formatter
rustup component add rustfmt
cargo fmt

# clippy: Linter
rustup component add clippy
cargo clippy

# Running clippy with specific lints
cargo clippy -- -W clippy::pedantic -A clippy::module_name_repetitions

# rustdoc: Documentation generator
cargo doc --open

// Backend web development with axum
use axum::{
    routing::get,
    Router,
};

async fn hello_world() -> &'static str {
    "Hello, World!"
}

#[tokio::main]
async fn main() {
    // Build our application with a single route
    let app = Router::new()
        .route("/", get(hello_world));

    // Run it with hyper on localhost:3000
    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}

// Frontend web development with Yew (WebAssembly)
use yew::prelude::*;

#[function_component]
fn App() -> Html {
    let counter = use_state(|| 0);
    let onclick = {
        let counter = counter.clone();
        move |_| {
            let value = *counter + 1;
            counter.set(value);
        }
    };

    html! {
        <div>
            <h1>{ "Counter: " } { *counter }</h1>
            <button {onclick}>{ "Increment" }</button>
        </div>
    }
}

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

// Embedded development with Embassy
#![no_std]
#![no_main]

use embassy_executor::Spawner;
use embassy_time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_stm32::peripherals::PA5;
use {defmt_rtt as _, panic_probe as _};

#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    let p = embassy_stm32::init(Default::default());
    let mut led = Output::new(p.PA5, Level::Low, Speed::Low);

    loop {
        led.set_high();
        Timer::after(Duration::from_millis(500)).await;
        led.set_low();
        Timer::after(Duration::from_millis(500)).await;
    }
}

// Game development with Bevy
use bevy::prelude::*;

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

#[derive(Component)]
struct Player;

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    // Camera
    commands.spawn(Camera2dBundle::default());
    
    // Player
    commands.spawn((
        SpriteBundle {
            texture: asset_server.load("player.png"),
            transform: Transform::from_xyz(0.0, 0.0, 0.0),
            ..default()
        },
        Player,
    ));
}

fn move_player(
    keyboard_input: Res<Input<KeyCode>>,
    mut query: Query<&mut Transform, With<Player>>,
    time: Res<Time>,
) {
    let mut player_transform = query.single_mut();
    let speed = 200.0;
    
    if keyboard_input.pressed(KeyCode::W) {
        player_transform.translation.y += speed * time.delta_seconds();
    }
    if keyboard_input.pressed(KeyCode::S) {
        player_transform.translation.y -= speed * time.delta_seconds();
    }
    if keyboard_input.pressed(KeyCode::A) {
        player_transform.translation.x -= speed * time.delta_seconds();
    }
    if keyboard_input.pressed(KeyCode::D) {
        player_transform.translation.x += speed * time.delta_seconds();
    }
}

// Machine learning with Burn
use burn::tensor::Tensor;
use burn::backend::Wgpu;
use burn::module::Module;
use burn::nn::{Linear, LinearConfig};
use burn::tensor::backend::Backend;

// Define a simple neural network
#[derive(Module, Debug)]
struct SimpleNN<B: Backend> {
    fc1: Linear<B>,
    fc2: Linear<B>,
}

impl<B: Backend> SimpleNN<B> {
    pub fn new() -> Self {
        let fc1 = LinearConfig::new(784, 128).init();
        let fc2 = LinearConfig::new(128, 10).init();
        
        Self { fc1, fc2 }
    }
    
    pub fn forward(&self, x: Tensor<B, 2>) -> Tensor<B, 2> {
        let x = self.fc1.forward(x).relu();
        self.fc2.forward(x)
    }
}

fn main() {
    // Create a model with the WGPU backend
    type MyBackend = Wgpu;
    let model = SimpleNN::<MyBackend>::new();
    
    // Create a random input tensor
    let batch_size = 64;
    let input = Tensor::<MyBackend, 2>::random(
        [batch_size, 784],
        burn::tensor::Distribution::Normal(0.0, 1.0),
    );
    
    // Forward pass
    let output = model.forward(input);
    println!("Output shape: {:?}", output.shape());
}

// Rust to WebAssembly with wasm-bindgen
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn fibonacci(n: u32) -> u32 {
    match n {
        0 => 0,
        1 => 1,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

#[wasm_bindgen]
pub fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

// Using Rust WebAssembly from JavaScript
import { fibonacci, greet } from './pkg/my_wasm_module.js';

console.log(fibonacci(10)); // 55
console.log(greet('World')); // "Hello, World!"

// Using Candle for machine learning
use candle_core::{Device, Result, Tensor};
use candle_nn::{Linear, Module, VarBuilder};

struct Model {
    linear1: Linear,
    linear2: Linear,
}

impl Model {
    fn new(vs: VarBuilder) -> Result<Self> {
        let linear1 = Linear::new(vs.pp("linear1"), 784, 128)?;
        let linear2 = Linear::new(vs.pp("linear2"), 128, 10)?;
        Ok(Self { linear1, linear2 })
    }
    
    fn forward(&self, xs: &Tensor) -> Result<Tensor> {
        let xs = self.linear1.forward(xs)?;
        let xs = xs.relu()?;
        self.linear2.forward(&xs)
    }
}

fn main() -> Result<()> {
    let device = Device::cuda_if_available(0)?;
    let vs = VarBuilder::zeros(candle_core::DType::F32, &device);
    let model = Model::new(vs)?;
    
    // Create a random input tensor
    let batch_size = 64;
    let xs = Tensor::randn(0f32, 1f32, (batch_size, 784), &device)?;
    
    // Forward pass
    let ys = model.forward(&xs)?;
    println!("Output shape: {:?}", ys.shape());
    
    Ok(())
}

// Building a Kubernetes operator with kube-rs
use kube::{
    api::{Api, ListParams, Patch, PatchParams},
    Client, CustomResource,
};
use kube_runtime::{controller::Controller, watcher};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use k8s_openapi::api::core::v1::Pod;
use futures::StreamExt;

#[derive(CustomResource, Serialize, Deserialize, Debug, Clone, JsonSchema)]
#[kube(
    group = "example.com",
    version = "v1",
    kind = "MyResource",
    namespaced
)]
struct MyResourceSpec {
    replicas: i32,
    image: String,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Initialize the Kubernetes client
    let client = Client::try_default().await?;
    
    // Create an API for our custom resource
    let resources = Api::<MyResource>::all(client.clone());
    
    // Create a controller for our custom resource
    Controller::new(resources, watcher::Config::default())
        .run(reconcile, error_policy, client)
        .for_each(|_| futures::future::ready(()))
        .await;
    
    Ok(())
}

async fn reconcile(resource: MyResource, client: Client) -> Result<(), kube::Error> {
    // Reconciliation logic here
    Ok(())
}

fn error_policy(_error: &kube::Error, _ctx: Arc<MyResource>) -> ReconcilerAction {
    ReconcilerAction::requeue(Duration::from_secs(5))
}

# Install Rust using rustup
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Verify installation
rustc --version
cargo --version

# Update Rust
rustup update

# Install additional components
rustup component add rustfmt clippy rust-analyzer

// Create a new project
// $ cargo new hello_world
// $ cd hello_world

// src/main.rs
fn main() {
    println!("Hello, world!");
    
    // Variables and basic types
    let x = 5;
    let y = 10.5;
    let name = "Rust";
    
    println!("x = {}, y = {}, name = {}", x, y, name);
    
    // Control flow
    if x > 0 {
        println!("x is positive");
    } else {
        println!("x is not positive");
    }
    
    // Loops
    for i in 0..5 {
        println!("i = {}", i);
    }
    
    // Functions
    println!("Sum: {}", add(x, 3));
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

# Build the project
cargo build

# Run the project
cargo run

# Build for release
cargo build --release

# Run tests
cargo test