Need help with JSONGen?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

204 Stars 14 Forks GNU General Public License v3.0 53 Commits 0 Opened issues


JSONGen is a tool for generating native Golang types from JSON objects.

Services available


Need anything else?

Contributors list

# 50,681
50 commits
# 661,697
1 commit


JSONGen is a tool for generating native Golang types from JSON objects. This automates what is otherwise a very tedious and error prone task when working with JSON.

Build Status GPLv3 License


$ jsongen -h
Usage of jsongen:
  -dump="NUL": Dump tree structure to file.
  -normalize=true: Squash arrays of struct and determine primitive array type.
  -title=true: Convert identifiers to title case, treating '_' and '-' as word boundaries.

Reading from stdin can be done as follows:

$ cat test.json | jsongen

Or a filename can be passed:

$ jsongen test.json

Using test.json as input the example will produce:

type _ struct {
    Bool              bool          `json:"bool"`
    Boollist          []bool        `json:"boollist"`
    Float             float64       `json:"float"`
    Floatlist         []float64     `json:"floatlist"`
    Heterogeneouslist []interface{} `json:"heterogeneouslist"`
    Int               int64         `json:"int"`
    Intlist           []int64       `json:"intlist"`
    Nil               interface{}   `json:"nil"`
    Nillist           []interface{} `json:"nillist"`
    Sanitary          string        `json:"_Sanitary"`
    Sanitary          string
    Sanitary0         string
    String            string   `json:"string"`
    Stringlist        []string `json:"stringlist"`
    Struct            struct {
        Bool   bool        `json:"bool"`
        Float  float64     `json:"float"`
        Int    int64       `json:"int"`
        Nil    interface{} `json:"nil"`
        String string      `json:"string"`
    } `json:"struct"`
    Structlist []struct {
        Bool   bool    `json:"bool"`
        Float  float64 `json:"float"`
        Int    int64   `json:"int"`
        String string  `json:"string"`
    } `json:"structlist"`
    Structlistsquash []struct {
        Bool   bool    `json:"bool"`
        Float  float64 `json:"float"`
        Int    int64   `json:"int"`
        String string  `json:"string"`
    } `json:"structlistsquash"`
    Structlistsquashconflict []struct {
        Bool     bool        `json:"bool"`
        Conflict interface{} `json:"conflict"`
        Float    float64     `json:"float"`
        Int      int64       `json:"int"`
        String   string      `json:"string"`
    } `json:"structlistsquashconflict"`
    TitleCase  string `json:"title case"`
    TitleCase  string `json:"title_case"`
    TitleCase  string `json:"title-case"`
    Titlecase  string `json:"titlecase"`
    Unsanitary string `json:"0Unsanitary"`
    _          string `json:"123"`


Field Names

  • Field names are sanitized and written as exported fields of the generated type.
  • If sanitizing produces an empty string the identifier is changed to
    , this will need to be set by hand in order to properly decode the type.
  • If sanitizing produces a field name different from the original value a JSON tag is added to the field.
  • Spaces and
    are converted to
  • Field names are converted to title case treating
    as word boundaries along with spaces. This can be disabled using



  • Primitive types are parsed and stored as-is.
  • Valid types are bool, int64, float64 and string.
  • The JSON value
    is translated to the empty interface.


  • Object types are treated as structs.
  • Fields of structures are sorted lexicographically by sanitized field name.
  • If a structure contains duplicate fields of different types, the type will be chosen at random since Golang's map iteration order is undefined. This shouldn't be a problem since this is not permitted in JSON specification, but this is the expected behavior should it happen.


  • A homogeneous list of primitive values are treated as a list of the primitive type e.g.:
  • Lists of heterogeneous types are treated as a list of the empty interface:
  • Lists containing both integers and floating point values are interpreted as
  • Lists with object elements are treated as a list of structs.
    • Fields of each element are "squashed" into a single struct. The result is an array of a struct containing all encountered fields.
    • If a field in one element has a different type in another of the same list, the offending field is treated as an empty interface.

Examples of all of the above can be found in test.json.


  • Currently sibling field names are not guaranteed to be unique.


The source of this project is licensed under GNU GPL v3.0, according to


  • Disclose Source: Source code must be made available when distributing the software. In the case of LGPL, the source for the library (and not the entire program) must be made available.
  • License and copyright notice: Include a copy of the license and copyright notice with the code.
  • State Changes: Indicate significant changes made to the code.


  • Commercial Use: This software and derivatives may be used for commercial purposes.
  • Distribution: You may distribute this software.
  • Modification: This software may be modified.
  • Patent Grant: This license provides an express grant of patent rights from the contributor to the recipient.
  • Private Use: You may use and modify the software without distributing it.


  • Hold Liable: Software is provided without warranty and the software author/license owner cannot be held liable for damages.
  • Sublicensing: You may not grant a sublicense to modify and distribute this software to third parties not included in the license.


If you find a case that produces incorrect results or you have a feature suggestion, let me know: submit an issue.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.