Serde for Rust: Complete Guide with Examples

What is Serde and why is it needed

Serde (short for Serialization/Deserialization) is a framework for serializing and deserializing data structures in the Rust language. It is the de facto standard for working with data formats in the Rust ecosystem. The library allows you to convert complex Rust types (structs, enums, vectors, hash maps) into various text and binary formats (JSON, YAML, TOML, BSON, MessagePack, CBOR, and many others) and back.

The main philosophy of Serde is performance without compromise. It uses Rust's powerful macro system to generate highly optimized code at compile time, making it one of the fastest serialization libraries among all programming languages. Serde is not tied to any specific format: it provides abstract traits Serialize and Deserialize, while specific formats are implemented in separate crates (e.g., serde_json, serde_yaml).

Why is Serde needed?

• State persistence: saving configurations, game saves, cache to disk
• Network protocols: data exchange between client and server (REST API, WebSocket)
• Configuration files: reading settings from JSON/YAML/TOML
• Databases: serializing records for storage in Redis, MongoDB, and other databases
• Inter-process communication: transferring data between processes via pipes or sockets

Installation

Serde is installed via the Cargo package manager, built into Rust. To get started, add dependencies to the Cargo.toml file:

[dependencies]serde = { version = "1.0", features = ["derive"] }serde_json = "1.0"

Explanation of dependencies:

• serde — the core of the library with the Serialize and Deserialize traits. The flag features = ["derive"] enables support for the #[derive(Serialize, Deserialize)] macro.
• serde_json — the JSON format implementation. Similarly, serde_yaml, serde_toml, bincode, and others can be added.

If you are working with Rust 2021 edition or newer, simply add these lines. To install a specific version, specify the version number, e.g., serde_json = "1.0.128".

Quick Start: First Example

Let's create a simple struct and serialize it to JSON, then deserialize it back:

use serde::{Deserialize, Serialize};use serde_json;

// Struct with automatic generation of serialization/deserialization code#[derive(Serialize, Deserialize, Debug)]struct User {    id: u32,    name: String,    email: String,    active: bool,}

fn main() {    // Create an instance of the struct    let user = User {        id: 42,        name: "Alice".to_string(),        email: "alice@example.com".to_string(),        active: true,    };

    // Serialize to JSON string    let json_string = serde_json::to_string(&user).unwrap();    println!("Serialized JSON: {}", json_string);

    // Deserialize back into the struct    let deserialized_user: User = serde_json::from_str(&json_string).unwrap();    println!("Deserialized struct: {:?}", deserialized_user);

    // Verify that data was not lost    assert_eq!(user.id, deserialized_user.id);    assert_eq!(user.name, deserialized_user.name);}

Program output:

Serialized JSON: {"id":42,"name":"Alice","email":"alice@example.com","active":true}Deserialized struct: User { id: 4