Expand description

This crate aims to compile the data formats extracted from Rust by serde-reflection into type definitions and (de)serialization methods for other programming languages.

It can be used as a library or as a command-line tool (see serdegen below).

Supported Languages

The following programming languages are fully supported as target languages:

  • C++ 17
  • Java 8
  • Python 3 (requires numpy >= 1.20.1)
  • Rust 2018
  • Go >= 1.14
  • C# (NetCoreApp >= 2.1)
  • Swift 5.3
  • OCaml

The following languages are partially supported and still considered under development:

Supported Encodings

Type definitions in a target language are meant to be used together with a runtime library that provides (de)serialization in a particular Serde encoding format.

This crate provides easy-to-deploy runtime libraries for the following binary formats, in all supported languages:

  • Bincode (default configuration only),
  • BCS (short for Binary Canonical Serialization, the main format used in the Diem blockchain).

Quick Start with Python and Bincode

In the following example, we transfer a Test value from Rust to Python using bincode.

use serde::{Deserialize, Serialize};
use serde_reflection::{Registry, Tracer, TracerConfig};
use std::io::Write;

#[derive(Serialize, Deserialize)]
struct Test {
    a: Vec<u64>,
    b: (u32, u32),

// Obtain the Serde format of `Test`. (In practice, formats are more likely read from a file.)
let mut tracer = Tracer::new(TracerConfig::default());
let registry = tracer.registry().unwrap();

// Create Python class definitions.
let mut source = Vec::new();
let config = serde_generate::CodeGeneratorConfig::new("testing".to_string())
let generator = serde_generate::python3::CodeGenerator::new(&config);
generator.output(&mut source, &registry)?;

class Test:
    a: typing.Sequence[st.uint64]
    b: typing.Tuple[st.uint32, st.uint32]

// Append some test code to demonstrate Bincode deserialization
// using the runtime in `serde_generate/runtime/python/bincode`.
value = Test.bincode_deserialize(bytes({:?}))
assert value == Test(a=[4, 6], b=(3, 5))
    bincode::serialize(&Test { a: vec![4, 6], b: (3, 5) }).unwrap(),

// Execute the Python code.
let mut child = std::process::Command::new("python3")
    .env("PYTHONPATH", std::env::var("PYTHONPATH").unwrap_or_default() + ":runtime/python")
let output = child.wait_with_output()?;

Binary Tool

In addition to a Rust library, this crate provides a binary tool serdegen to process Serde formats saved on disk.

The tool serdegen assumes that a Rust value of type serde_reflection::Registry has been serialized into a YAML file. The recommended way to generate such a value is to use the library serde-reflection to introspect Rust definitions (see also the example above).

For a quick test, one may create a test file like this:

cat >test.yaml <<EOF
      B: UNIT

Then, the following command will generate Python class definitions and write them into test.py:

cargo run -p serde-generate -- --language python3 test.yaml > test.py

To create a python module test and install the bincode runtime in a directory $DEST, you may run:

cargo run -p serde-generate -- --language python3 --with-runtimes serde bincode --module-name test --target-source-dir "$DEST" test.yaml

See the help message of the tool with --help for more options.

Note: Outside of this repository, you may install the tool with cargo install serde-generate then use $HOME/.cargo/bin/serdegen.


Dependency analysis and topological sort for Serde formats.

Support for code-generation in C++

Support for code-generation in C#

Support for code-generation in Dart

Support for code-generation in Go

Utility function to generate indented text

Support for code-generation in Java

Support for code-generation in OCaml

Support for code-generation in Python 3

Support for code-generation in Rust

Support for code-generation in Swift

Support for code-generation in TypeScript/JavaScript


Code generation options meant to be supported by all languages.



How to copy generated source code and available runtimes for a given language.

Type Definitions

Track custom code to be added to particular definitions (use with care!).

Track documentation to be attached to particular definitions.

Track types definitions provided by external modules.