Programming language: Go
License: MIT License
Tags: Code Analysis    
Latest version: v1.5.2

GoPlantUML alternatives and similar packages

Based on the "Code Analysis" category.
Alternatively, view GoPlantUML alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of GoPlantUML or a related project?

Add another 'Code Analysis' Package


godoc reference Go Report Card codecov License: MIT GitHub release Build Status Mentioned in Awesome Go DUMELS Diagram

GoPlantUML V2

PlantUML Class Diagram Generator for golang projects. Generates class diagram text compatible with plantuml with the information of all structures and interfaces as well as the relationship among them.

Want to try it on your code?

Take a look at www.dumels.com. We have created dumels using this library.

Code of Conduct

Please, review the code of conduct here.


golang 1.17 or above


go get github.com/jfeliu007/goplantuml/parser
go install github.com/jfeliu007/goplantuml/cmd/goplantuml@latest

This will install the command goplantuml in your GOPATH bin folder.


goplantuml [-recursive] path/to/gofiles path/to/gofiles2
goplantuml [-recursive] path/to/gofiles path/to/gofiles2 > diagram_file_name.puml
Usage of goplantuml:
        Show aggregations for private members. Ignored if -show-aggregations is not used.
        hides all connections in the diagram
        hides fields
        hides methods
  -ignore string
        comma separated list of folders to ignore
  -notes string
        Comma separated list of notes to be added to the diagram
  -output string
        output file path. If omitted, then this will default to standard output
        walk all directories recursively
        renders public aggregations even when -hide-connections is used (do not render by default)
        Shows aliases even when -hide-connections is used
        Shows compositions even when -hide-connections is used
        Shows labels in the connections to identify the connections types (e.g. extends, implements, aggregates, alias of
        Shows implementations even when -hide-connections is used
        Show a note in the diagram with the none evident options ran with this CLI
  -title string
        Title of the generated diagram
        Hides all private members (fields and methods)


goplantuml $GOPATH/src/github.com/jfeliu007/goplantuml/parser
// echoes

namespace parser {
    class Struct {
        + Functions []*Function
        + Fields []*Parameter
        + Type string
        + Composition []string
        + Extends []string

    class LineStringBuilder {
        + WriteLineWithDepth(depth int, str string) 

    class ClassParser {
        - structure <font color=blue>map</font>[string]<font color=blue>map</font>[string]*Struct
        - currentPackageName string
        - allInterfaces <font color=blue>map</font>[string]<font color=blue>struct</font>{}
        - allStructs <font color=blue>map</font>[string]<font color=blue>struct</font>{}

        - structImplementsInterface(st *Struct, inter *Struct) 
        - parsePackage(node ast.Node) 
        - parseFileDeclarations(node ast.Decl) 
        - addMethodToStruct(s *Struct, method *ast.Field) 
        - getFunction(f *ast.FuncType, name string) 
        - addFieldToStruct(s *Struct, field *ast.Field) 
        - addToComposition(s *Struct, fType string) 
        - addToExtends(s *Struct, fType string) 
        - getOrCreateStruct(name string) 
        - getStruct(structName string) 
        - getFieldType(exp ast.Expr, includePackageName bool) 

        + Render() 

    class Parameter {
        + Name string
        + Type string

    class Function {
        + Name string
        + Parameters []*Parameter
        + ReturnValues []string

strings.Builder *-- parser.LineStringBuilder

goplantuml $GOPATH/src/github.com/jfeliu007/goplantuml/parser > ClassDiagram.puml
// Generates a file ClassDiagram.plum with the previous specifications

There are two different relationships considered in goplantuml:

  • Interface implementation
  • Type Composition

The following example contains interface implementations and composition. Notice how the signature of the functions

package testingsupport

//MyInterface only has one method, notice the signature return value
type MyInterface interface {
    foo() bool

//MyStruct1 will implement the foo() bool function so it will have an "extends" association with MyInterface
type MyStruct1 struct {

func (s1 *MyStruct1) foo() bool {
    return true

//MyStruct2 will be directly composed of MyStruct1 so it will have a composition relationship with it
type MyStruct2 struct {

//MyStruct3 will have a foo() function but the return value is not a bool, so it will not have any relationship with MyInterface
type MyStruct3 struct {
    Foo MyStruct1

func (s3 *MyStruct3) foo() {


This will be generated from the previous code

namespace testingsupport {
    interface MyInterface  {
        - foo() bool

    class MyStruct1 << (S,Aquamarine) >> {
        - foo() bool

    class MyStruct2 << (S,Aquamarine) >> {
    class MyStruct3 << (S,Aquamarine) >> {
        - foo() 

        + Foo MyStruct1

testingsupport.MyStruct1 *-- testingsupport.MyStruct2

testingsupport.MyInterface <|-- testingsupport.MyStruct1

testingsupport.MyStruct3 o-- testingsupport.MyStruct1


alt text

Diagram using www.dumels.com

UML Diagram

*Note that all licence references and agreements mentioned in the GoPlantUML README section above are relevant to that project's source code only.