Skip to content
Go to file

Latest commit

Makes it so that even if there would otherwise be no code to generate,
if you say you want a type Foobar, you can still refer to Foobar,
instead of getting an error.

The name will still coerced to a valid type name though. Something to
consider for the rewrite, if that is a good idea at all.

Closes #18

Co-authored-by: Gygaxis Vainhardt <>

Git stats


Failed to load latest commit information.
Latest commit message
Commit time

json_typegen - Rust types from JSON samples

Travis Build Status Appveyor build status

json_typegen is a collection of tools for generating Rust types (++) from JSON samples, built on top of serde. I.e. you give it some JSON, and it gives you the type definitions necessary to use that JSON in a Rust program. If you are familiar with F#, the procedural macro json_typegen! works as a type provider for JSON in Rust. It was inspired by and uses the same kind of inference algorithm as F# Data.

There are three interfaces to this code generation logic:

The CLI and web interface also produces types for other languages than Rust. Namely Kotlin, TypeScript and JSON Schemas.

Procedural macro

The first interface to the code generation tools is a procedural macro json_typegen!. As an example, the below code generates code for the type Point.

use json_typegen::json_typegen;

json_typegen!("pub Point", r#"{ "x": 1, "y": 2 }"#);

fn main() {
    let mut p: Point = serde_json::from_str(r#"{ "x": 3, "y": 5 }"#).unwrap();
    println!("deserialized = {:?}", p);
    p.x = 4;
    let serialized = serde_json::to_string(&p).unwrap();
    println!("serialized = {}", serialized);
serde = "1.0"
serde_derive = "1.0"
serde_json = "1.0"
json_typegen = "0.4"

The sample json can also come from local or remote files:

json_typegen!("pub Point", "json_samples/point.json");
json_typegen!("pub Point", "");

The code generation can also be customized:

json_typegen!("pub Point", "", {
    "/foo/bar": {
        use_type: "map"

For the details, see the relevant documentation.

Conditional compilation

To avoid incurring the cost of a HTTP request per sample used for every build you can use conditional compilation to only check against remote samples when desired:

#[cfg(not(feature = "online-samples"))]
json_typegen!("pub Point", r#"{ "x": 1, "y": 2 }"#);
#[cfg(feature = "online-samples")]
json_typegen!("pub Point", "");

And in Cargo.toml:

online-samples = []

You can then verify that remote samples match your expectations in e.g. CI builds as follows:

cargo check --features "online-samples"

Command line interface

The crate json_typegen_cli provides a CLI to the same code generation as the procedural macro uses internally. This provides a useful migration path if you at some point need to customize the generated code beyond what is practical through macro arguments.

For details on usage see its readme.

Web interface

For simple testing and one-time use there is also a web interface (in json_typegen_web). An instance of this interface is currently hosted at

Creating your own type provider crate

Both procedural macros and the shape inference algorithm are actually very simple. To learn/copy the algorithm you can look at this stripped-down version(< 200 lines).


This project is dual licensed, under either the Apache 2.0 or the MIT license, at your option.

You can’t perform that action at this time.