serde-rs logo


Serialization framework for Rust (by serde-rs)


Basic serde repo stats
18 days ago

serde-rs/serde is an open source project licensed under GNU General Public License v3.0 or later which is an OSI approved license.

Serde Alternatives

Similar projects and alternatives to serde
  • GitHub repo unsafe-code-guidelines

    Home for the Unsafe Code Guidelines working group.

  • GitHub repo tokio

    A runtime for writing reliable asynchronous applications with Rust. Provides I/O, networking, scheduling, timers, ...

  • GitHub repo ocaml

    The core OCaml system: compilers, runtime system, base libraries

  • GitHub repo cargo-crev

    A cryptographically verifiable code review system for the cargo (Rust) package manager.

  • GitHub repo clido

    A tool for creating and maintaining a todo-list on the command line

  • GitHub repo rust

    Empowering everyone to build reliable and efficient software.

  • GitHub repo bevy

    A refreshingly simple data-driven game engine built in Rust

  • GitHub repo windows-rs

    Rust for Windows

  • GitHub repo warp

    A super-easy, composable, web server framework for warp speeds.

  • GitHub repo reqwest

    An easy and powerful Rust HTTP Client

  • GitHub repo rfcs

    RFCs for changes to Rust

  • GitHub repo json

    Strongly typed JSON library for Rust (by serde-rs)

  • GitHub repo

    Source code for

  • GitHub repo Paste JSON as Code • quicktype

    Xcode extension to paste JSON as Swift, Objective-C, and more

  • GitHub repo too-many-lists

    Learn Rust by writing Entirely Too Many linked lists

  • GitHub repo cargo-audit

    Audit Cargo.lock files for crates with security vulnerabilities

  • GitHub repo uom

    Units of measurement -- type-safe zero-cost dimensional analysis

  • GitHub repo x11rb

    X11 bindings for the rust programming language, similar to xcb being the X11 C bindings

  • GitHub repo macchina

    A system information fetcher, with a focus on performance and minimalism. [Moved to:] (by grtcdr)

  • GitHub repo jelly-actix-web-starter

    A starter template for actix-web projects that feels very Django-esque. Avoid the boring stuff and move faster.

NOTE: The number of mentions on this list indicates mentions on common posts. Hence, a higher number means a better serde alternative or higher similarity.


Posts where serde has been mentioned. We have used some of these posts to build our list of alternatives and similar projects - the last one was on 2021-04-08.
  • Why is rust a productive language and how is the relationship between webassambly? | 2021-04-08
    Serde and StructOpt are hard to match (let alone beat) for declarative programming, especially when paired with things like validator.
  • Autogenerate large struct to deserialize json | 2021-04-03
    There is serde ( which has serde-json on
  • Thoughts on Rust Bloat | 2021-03-29
    > I think a big part of the problem is that we try to map our programming language data types directly to serialized types

    Much of the time, in-program data is relational with a possibly-cyclic graph describing relationships, ownership, etc. Systems that work with RDBMSes do a fine job of de/serializing data for relational stores, and ORMs are a powerful and delightful way to do this.

    The problem with JSON and XML for these kinds of data is these formats are inherently non-relational. They are simple trees of data, not arbitrary graphs. In practice, e.g. in every full-stack web codebase I've ever seen, JSON blobs are hacked together e.g. by doing a makeshift front-end "join by ID" when needed — or adjusting a back-end method to perform the join and return — wait for it — a flattened JSON blob.

    It seems like we need a "JSON" or "XML" where relationships are a first-class citizen. To my knowledge, the closest we've come to this is when the data broker and format are tightly coupled, e.g. with SOAP or GraphQL. Can this be achieved strictly decoratively, in a format that's better than a SQL data dump? Maybe!

    > I wonder if a system similar to Scheme's `syntax-rules` (or Rust's `macro_rules!`) for mapping the serialized data into the program's data types (and vice-versa) would be a nice mechanism.

    Does `serde`[1] look like it's close to your imagined mark? I haven't tried it personally, but it looks akin to Java's `Serializable` or C#'s `ISerializable`— all reasonably elegant ways of handling the messy binding logic of serialization over arbitrary formats.


  • Now that the long-awaited const generics (MVP) have come to stable in 1.51, what crates are going to gain the most from it? | 2021-03-25
    I am hoping it can enable serde to support arbitrary length array. However, there seems to be some backward compatibility issues blocking the change.
  • What’s everyone working on this week (12/2021)? | 2021-03-22
    serde for serializing/deserializing json data
  • Lost in writing iterator for a struct in rust | 2021-03-20
    There are crates like arraygen which will help you do this, but I would definitely think about trying to find a more idiomatic way to accomplish whatever your end goal is. For instance, if you are just trying to save the state to a file it would make a certain amount of sense to iterate through the fields and write the name and then value out, but the more idiomatic way to do it would be to use something like serde to serialize the whole thing at once. | 2021-03-20
    What it sounds to me like you actually are looking for is more along of the lines of serialization functionality, for which I'd recommend looking at the serde crate for.
  • Hey Rustaceans! Got an easy question? Ask here (9/2021)! | 2021-03-01
    It looks like the feature I'm looking for is waiting to be implemented here:
  • C++ programmers who are also using rust, what are your favourite features of rust? | 2021-02-26
    Let's take a look at the hallmark of Rust's ecosystem: serde. It's data model has type byte array. Many people simply assume that serde maps Vec to a byte array: it's the most natural and efficient thing to do, right?
  • How can I test that two structs are equal? | 2021-02-24
    With serde, try to deserialize responses to the expected struct with this attribute.
  • Validating JSON input in Rust web services | 2021-02-14
    serde is serialization and deserialization framework
  • Anticipating the Rust growth and preparing for it | 2021-01-27
    This is very likely not cargo-crev's fault, its a change in type inference resolution caused by serde making an impl public:
  • Rust Design Patterns as a Book | 2021-01-02
    I guess you are talking about this `Visitor` trait [0]. I have only used serde in combination with the derive macros so please enlighten me, but each `visit_` function of the `Visitor` trait already takes a typed value (`bool`, integer types, ...) so these already have too be parsed (instantiated?) from the input string/bytes. Couldn't you have an `SerdeTypes` enum that implements `From` for each `visit_` type to remove some boilerplate and then use pattern matching? Could you elaborate where there would be overhead, I'm missing? Don't get me wrong, I'm pretty sure, the serde developers know better than me and have good reasons to implement it the way they did, but I'd like to understand the rational behind the decision.