PlantUML Language specification Theme Gallery

       

Edit in DokuwikiEdit in AsciidocEdit in Markdown

Theme Gallery

Edit in DokuwikiEdit in AsciidocEdit in Markdown

List of all themes

@startuml help themes @enduml

amiga

Activity with amiga theme

@startuml @startuml !theme amiga start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with amiga theme

@startuml @startuml !theme amiga abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with amiga theme

@startuml @startuml !theme amiga actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with amiga theme

@startuml @startuml !theme amiga [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with amiga theme

@startuml @startmindmap !theme amiga + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with amiga theme

@startuml @startuml !theme amiga nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with amiga theme

@startuml @startuml !theme amiga object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with amiga theme

@startuml @startsalt !theme amiga {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with amiga theme

@startuml @startuml !theme amiga participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with amiga theme

@startuml @startuml !theme amiga state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with amiga theme

@startuml @startuml !theme amiga robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with amiga theme

@startuml @startwbs !theme amiga * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

aws-orange

Activity with aws-orange theme

@startuml @startuml !theme aws-orange start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with aws-orange theme

@startuml @startuml !theme aws-orange abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with aws-orange theme

@startuml @startuml !theme aws-orange actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with aws-orange theme

@startuml @startuml !theme aws-orange [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with aws-orange theme

@startuml @startmindmap !theme aws-orange + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with aws-orange theme

@startuml @startuml !theme aws-orange nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with aws-orange theme

@startuml @startuml !theme aws-orange object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with aws-orange theme

@startuml @startsalt !theme aws-orange {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with aws-orange theme

@startuml @startuml !theme aws-orange participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with aws-orange theme

@startuml @startuml !theme aws-orange state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with aws-orange theme

@startuml @startuml !theme aws-orange robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with aws-orange theme

@startuml @startwbs !theme aws-orange * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme black-knight

Activity with black-knight theme

@startuml @startuml !theme black-knight start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with black-knight theme

@startuml @startuml !theme black-knight abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with black-knight theme

@startuml @startuml !theme black-knight actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with black-knight theme

@startuml @startuml !theme black-knight [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with black-knight theme

@startuml @startmindmap !theme black-knight + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with black-knight theme

@startuml @startuml !theme black-knight nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with black-knight theme

@startuml @startuml !theme black-knight object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with black-knight theme

@startuml @startsalt !theme black-knight {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with black-knight theme

@startuml @startuml !theme black-knight participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with black-knight theme

@startuml @startuml !theme black-knight state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with black-knight theme

@startuml @startuml !theme black-knight robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with black-knight theme

@startuml @startwbs !theme black-knight * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme bluegray

Activity with bluegray theme

@startuml @startuml !theme bluegray start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with bluegray theme

@startuml @startuml !theme bluegray abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with bluegray theme

@startuml @startuml !theme bluegray actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with bluegray theme

@startuml @startuml !theme bluegray [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with bluegray theme

@startuml @startmindmap !theme bluegray + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with bluegray theme

@startuml @startuml !theme bluegray nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with bluegray theme

@startuml @startuml !theme bluegray object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with bluegray theme

@startuml @startsalt !theme bluegray {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with bluegray theme

@startuml @startuml !theme bluegray participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with bluegray theme

@startuml @startuml !theme bluegray state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with bluegray theme

@startuml @startuml !theme bluegray robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with bluegray theme

@startuml @startwbs !theme bluegray * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme blueprint

Activity with blueprint theme

@startuml @startuml !theme blueprint start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with blueprint theme

@startuml @startuml !theme blueprint abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with blueprint theme

@startuml @startuml !theme blueprint actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with blueprint theme

@startuml @startuml !theme blueprint [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with blueprint theme

@startuml @startmindmap !theme blueprint + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with blueprint theme

@startuml @startuml !theme blueprint nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with blueprint theme

@startuml @startuml !theme blueprint object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with blueprint theme

@startuml @startsalt !theme blueprint {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with blueprint theme

@startuml @startuml !theme blueprint participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with blueprint theme

@startuml @startuml !theme blueprint state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with blueprint theme

@startuml @startuml !theme blueprint robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with blueprint theme

@startuml @startwbs !theme blueprint * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme cerulean

Activity with cerulean theme

@startuml @startuml !theme cerulean start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with cerulean theme

@startuml @startuml !theme cerulean abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with cerulean theme

@startuml @startuml !theme cerulean actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with cerulean theme

@startuml @startuml !theme cerulean [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with cerulean theme

@startuml @startmindmap !theme cerulean + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with cerulean theme

@startuml @startuml !theme cerulean nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with cerulean theme

@startuml @startuml !theme cerulean object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with cerulean theme

@startuml @startsalt !theme cerulean {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with cerulean theme

@startuml @startuml !theme cerulean participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with cerulean theme

@startuml @startuml !theme cerulean state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with cerulean theme

@startuml @startuml !theme cerulean robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with cerulean theme

@startuml @startwbs !theme cerulean * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme cerulean-outline

Activity with cerulean-outline theme

@startuml @startuml !theme cerulean-outline start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with cerulean-outline theme

@startuml @startuml !theme cerulean-outline abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with cerulean-outline theme

@startuml @startuml !theme cerulean-outline actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with cerulean-outline theme

@startuml @startuml !theme cerulean-outline [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with cerulean-outline theme

@startuml @startmindmap !theme cerulean-outline + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with cerulean-outline theme

@startuml @startuml !theme cerulean-outline nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with cerulean-outline theme

@startuml @startuml !theme cerulean-outline object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with cerulean-outline theme

@startuml @startsalt !theme cerulean-outline {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with cerulean-outline theme

@startuml @startuml !theme cerulean-outline participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with cerulean-outline theme

@startuml @startuml !theme cerulean-outline state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with cerulean-outline theme

@startuml @startuml !theme cerulean-outline robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with cerulean-outline theme

@startuml @startwbs !theme cerulean-outline * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme crt-amber

Activity with crt-amber theme

@startuml @startuml !theme crt-amber start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with crt-amber theme

@startuml @startuml !theme crt-amber abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with crt-amber theme

@startuml @startuml !theme crt-amber actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with crt-amber theme

@startuml @startuml !theme crt-amber [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with crt-amber theme

@startuml @startmindmap !theme crt-amber + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with crt-amber theme

@startuml @startuml !theme crt-amber nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with crt-amber theme

@startuml @startuml !theme crt-amber object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with crt-amber theme

@startuml @startsalt !theme crt-amber {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with crt-amber theme

@startuml @startuml !theme crt-amber participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with crt-amber theme

@startuml @startuml !theme crt-amber state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with crt-amber theme

@startuml @startuml !theme crt-amber robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with crt-amber theme

@startuml @startwbs !theme crt-amber * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme crt-green

Activity with crt-green theme

@startuml @startuml !theme crt-green start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with crt-green theme

@startuml @startuml !theme crt-green abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with crt-green theme

@startuml @startuml !theme crt-green actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with crt-green theme

@startuml @startuml !theme crt-green [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with crt-green theme

@startuml @startmindmap !theme crt-green + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with crt-green theme

@startuml @startuml !theme crt-green nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with crt-green theme

@startuml @startuml !theme crt-green object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with crt-green theme

@startuml @startsalt !theme crt-green {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with crt-green theme

@startuml @startuml !theme crt-green participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with crt-green theme

@startuml @startuml !theme crt-green state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with crt-green theme

@startuml @startuml !theme crt-green robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with crt-green theme

@startuml @startwbs !theme crt-green * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme cyborg

Activity with cyborg theme

@startuml @startuml !theme cyborg start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with cyborg theme

@startuml @startuml !theme cyborg abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with cyborg theme

@startuml @startuml !theme cyborg actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with cyborg theme

@startuml @startuml !theme cyborg [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with cyborg theme

@startuml @startmindmap !theme cyborg + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with cyborg theme

@startuml @startuml !theme cyborg nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with cyborg theme

@startuml @startuml !theme cyborg object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with cyborg theme

@startuml @startsalt !theme cyborg {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with cyborg theme

@startuml @startuml !theme cyborg participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with cyborg theme

@startuml @startuml !theme cyborg state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with cyborg theme

@startuml @startuml !theme cyborg robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with cyborg theme

@startuml @startwbs !theme cyborg * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme cyborg-outline

Activity with cyborg-outline theme

@startuml @startuml !theme cyborg-outline start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with cyborg-outline theme

@startuml @startuml !theme cyborg-outline abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with cyborg-outline theme

@startuml @startuml !theme cyborg-outline actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with cyborg-outline theme

@startuml @startuml !theme cyborg-outline [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with cyborg-outline theme

@startuml @startmindmap !theme cyborg-outline + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with cyborg-outline theme

@startuml @startuml !theme cyborg-outline nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with cyborg-outline theme

@startuml @startuml !theme cyborg-outline object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with cyborg-outline theme

@startuml @startsalt !theme cyborg-outline {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with cyborg-outline theme

@startuml @startuml !theme cyborg-outline participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with cyborg-outline theme

@startuml @startuml !theme cyborg-outline state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with cyborg-outline theme

@startuml @startuml !theme cyborg-outline robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with cyborg-outline theme

@startuml @startwbs !theme cyborg-outline * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme hacker

Activity with hacker theme

@startuml @startuml !theme hacker start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with hacker theme

@startuml @startuml !theme hacker abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with hacker theme

@startuml @startuml !theme hacker actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with hacker theme

@startuml @startuml !theme hacker [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with hacker theme

@startuml @startmindmap !theme hacker + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with hacker theme

@startuml @startuml !theme hacker nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with hacker theme

@startuml @startuml !theme hacker object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with hacker theme

@startuml @startsalt !theme hacker {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with hacker theme

@startuml @startuml !theme hacker participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with hacker theme

@startuml @startuml !theme hacker state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with hacker theme

@startuml @startuml !theme hacker robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with hacker theme

@startuml @startwbs !theme hacker * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme lightgray

Activity with lightgray theme

@startuml @startuml !theme lightgray start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with lightgray theme

@startuml @startuml !theme lightgray abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with lightgray theme

@startuml @startuml !theme lightgray actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with lightgray theme

@startuml @startuml !theme lightgray [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with lightgray theme

@startuml @startmindmap !theme lightgray + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with lightgray theme

@startuml @startuml !theme lightgray nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with lightgray theme

@startuml @startuml !theme lightgray object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with lightgray theme

@startuml @startsalt !theme lightgray {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with lightgray theme

@startuml @startuml !theme lightgray participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with lightgray theme

@startuml @startuml !theme lightgray state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with lightgray theme

@startuml @startuml !theme lightgray robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with lightgray theme

@startuml @startwbs !theme lightgray * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme materia

Activity with materia theme

@startuml @startuml !theme materia start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with materia theme

@startuml @startuml !theme materia abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with materia theme

@startuml @startuml !theme materia actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with materia theme

@startuml @startuml !theme materia [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with materia theme

@startuml @startmindmap !theme materia + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with materia theme

@startuml @startuml !theme materia nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with materia theme

@startuml @startuml !theme materia object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with materia theme

@startuml @startsalt !theme materia {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with materia theme

@startuml @startuml !theme materia participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with materia theme

@startuml @startuml !theme materia state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with materia theme

@startuml @startuml !theme materia robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with materia theme

@startuml @startwbs !theme materia * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme materia-outline

Activity with materia-outline theme

@startuml @startuml !theme materia-outline start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with materia-outline theme

@startuml @startuml !theme materia-outline abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with materia-outline theme

@startuml @startuml !theme materia-outline actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with materia-outline theme

@startuml @startuml !theme materia-outline [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with materia-outline theme

@startuml @startmindmap !theme materia-outline + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with materia-outline theme

@startuml @startuml !theme materia-outline nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with materia-outline theme

@startuml @startuml !theme materia-outline object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with materia-outline theme

@startuml @startsalt !theme materia-outline {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with materia-outline theme

@startuml @startuml !theme materia-outline participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with materia-outline theme

@startuml @startuml !theme materia-outline state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with materia-outline theme

@startuml @startuml !theme materia-outline robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with materia-outline theme

@startuml @startwbs !theme materia-outline * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme metal

Activity with metal theme

@startuml @startuml !theme metal start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with metal theme

@startuml @startuml !theme metal abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with metal theme

@startuml @startuml !theme metal actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with metal theme

@startuml @startuml !theme metal [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with metal theme

@startuml @startmindmap !theme metal + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with metal theme

@startuml @startuml !theme metal nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with metal theme

@startuml @startuml !theme metal object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with metal theme

@startuml @startsalt !theme metal {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with metal theme

@startuml @startuml !theme metal participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with metal theme

@startuml @startuml !theme metal state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with metal theme

@startuml @startuml !theme metal robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with metal theme

@startuml @startwbs !theme metal * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme mimeograph

Activity with mimeograph theme

@startuml @startuml !theme mimeograph start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with mimeograph theme

@startuml @startuml !theme mimeograph abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with mimeograph theme

@startuml @startuml !theme mimeograph actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with mimeograph theme

@startuml @startuml !theme mimeograph [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with mimeograph theme

@startuml @startmindmap !theme mimeograph + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with mimeograph theme

@startuml @startuml !theme mimeograph nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with mimeograph theme

@startuml @startuml !theme mimeograph object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with mimeograph theme

@startuml @startsalt !theme mimeograph {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with mimeograph theme

@startuml @startuml !theme mimeograph participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with mimeograph theme

@startuml @startuml !theme mimeograph state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with mimeograph theme

@startuml @startuml !theme mimeograph robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with mimeograph theme

@startuml @startwbs !theme mimeograph * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme minty

Activity with minty theme

@startuml @startuml !theme minty start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with minty theme

@startuml @startuml !theme minty abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with minty theme

@startuml @startuml !theme minty actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with minty theme

@startuml @startuml !theme minty [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with minty theme

@startuml @startmindmap !theme minty + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with minty theme

@startuml @startuml !theme minty nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with minty theme

@startuml @startuml !theme minty object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with minty theme

@startuml @startsalt !theme minty {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with minty theme

@startuml @startuml !theme minty participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with minty theme

@startuml @startuml !theme minty state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with minty theme

@startuml @startuml !theme minty robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with minty theme

@startuml @startwbs !theme minty * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme plain

Activity with plain theme

@startuml @startuml !theme plain start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with plain theme

@startuml @startuml !theme plain abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with plain theme

@startuml @startuml !theme plain actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with plain theme

@startuml @startuml !theme plain [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with plain theme

@startuml @startmindmap !theme plain + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with plain theme

@startuml @startuml !theme plain nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with plain theme

@startuml @startuml !theme plain object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with plain theme

@startuml @startsalt !theme plain {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with plain theme

@startuml @startuml !theme plain participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with plain theme

@startuml @startuml !theme plain state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with plain theme

@startuml @startuml !theme plain robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with plain theme

@startuml @startwbs !theme plain * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme resume-light

Activity with resume-light theme

@startuml @startuml !theme resume-light start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with resume-light theme

@startuml @startuml !theme resume-light abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with resume-light theme

@startuml @startuml !theme resume-light actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with resume-light theme

@startuml @startuml !theme resume-light [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with resume-light theme

@startuml @startmindmap !theme resume-light + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with resume-light theme

@startuml @startuml !theme resume-light nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with resume-light theme

@startuml @startuml !theme resume-light object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with resume-light theme

@startuml @startsalt !theme resume-light {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with resume-light theme

@startuml @startuml !theme resume-light participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with resume-light theme

@startuml @startuml !theme resume-light state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with resume-light theme

@startuml @startuml !theme resume-light robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with resume-light theme

@startuml @startwbs !theme resume-light * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme sandstone

Activity with sandstone theme

@startuml @startuml !theme sandstone start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with sandstone theme

@startuml @startuml !theme sandstone abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with sandstone theme

@startuml @startuml !theme sandstone actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with sandstone theme

@startuml @startuml !theme sandstone [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with sandstone theme

@startuml @startmindmap !theme sandstone + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with sandstone theme

@startuml @startuml !theme sandstone nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with sandstone theme

@startuml @startuml !theme sandstone object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with sandstone theme

@startuml @startsalt !theme sandstone {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with sandstone theme

@startuml @startuml !theme sandstone participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with sandstone theme

@startuml @startuml !theme sandstone state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with sandstone theme

@startuml @startuml !theme sandstone robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with sandstone theme

@startuml @startwbs !theme sandstone * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme silver

Activity with silver theme

@startuml @startuml !theme silver start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with silver theme

@startuml @startuml !theme silver abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with silver theme

@startuml @startuml !theme silver actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with silver theme

@startuml @startuml !theme silver [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with silver theme

@startuml @startmindmap !theme silver + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with silver theme

@startuml @startuml !theme silver nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with silver theme

@startuml @startuml !theme silver object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with silver theme

@startuml @startsalt !theme silver {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with silver theme

@startuml @startuml !theme silver participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with silver theme

@startuml @startuml !theme silver state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with silver theme

@startuml @startuml !theme silver robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with silver theme

@startuml @startwbs !theme silver * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme sketchy

Activity with sketchy theme

@startuml @startuml !theme sketchy start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with sketchy theme

@startuml @startuml !theme sketchy abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with sketchy theme

@startuml @startuml !theme sketchy actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with sketchy theme

@startuml @startuml !theme sketchy [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with sketchy theme

@startuml @startmindmap !theme sketchy + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with sketchy theme

@startuml @startuml !theme sketchy nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with sketchy theme

@startuml @startuml !theme sketchy object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with sketchy theme

@startuml @startsalt !theme sketchy {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with sketchy theme

@startuml @startuml !theme sketchy participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with sketchy theme

@startuml @startuml !theme sketchy state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with sketchy theme

@startuml @startuml !theme sketchy robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with sketchy theme

@startuml @startwbs !theme sketchy * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme sketchy-outline

Activity with sketchy-outline theme

@startuml @startuml !theme sketchy-outline start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Theme sketchy-outline

Activity with sketchy-outline theme

@startuml @startuml !theme sketchy-outline start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with sketchy-outline theme

@startuml @startuml !theme sketchy-outline abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with sketchy-outline theme

@startuml @startuml !theme sketchy-outline actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with sketchy-outline theme

@startuml @startuml !theme sketchy-outline [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with sketchy-outline theme

@startuml @startmindmap !theme sketchy-outline + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with sketchy-outline theme

@startuml @startuml !theme sketchy-outline nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with sketchy-outline theme

@startuml @startuml !theme sketchy-outline object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with sketchy-outline theme

@startuml @startsalt !theme sketchy-outline {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with sketchy-outline theme

@startuml @startuml !theme sketchy-outline participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with sketchy-outline theme

@startuml @startuml !theme sketchy-outline state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with sketchy-outline theme

@startuml @startuml !theme sketchy-outline robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with sketchy-outline theme

@startuml @startwbs !theme sketchy-outline * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme spacelab

Activity with spacelab theme

@startuml @startuml !theme spacelab start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with spacelab theme

@startuml @startuml !theme spacelab abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with spacelab theme

@startuml @startuml !theme spacelab actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with spacelab theme

@startuml @startuml !theme spacelab [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with spacelab theme

@startuml @startmindmap !theme spacelab + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with spacelab theme

@startuml @startuml !theme spacelab nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with spacelab theme

@startuml @startuml !theme spacelab object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with spacelab theme

@startuml @startsalt !theme spacelab {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with spacelab theme

@startuml @startuml !theme spacelab participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with spacelab theme

@startuml @startuml !theme spacelab state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with spacelab theme

@startuml @startuml !theme spacelab robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with spacelab theme

@startuml @startwbs !theme spacelab * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme toy

Activity with toy theme

@startuml @startuml !theme toy start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with toy theme

@startuml @startuml !theme toy abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with toy theme

@startuml @startuml !theme toy actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with toy theme

@startuml @startuml !theme toy [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with toy theme

@startuml @startmindmap !theme toy + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with toy theme

@startuml @startuml !theme toy nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with toy theme

@startuml @startuml !theme toy object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with toy theme

@startuml @startsalt !theme toy {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with toy theme

@startuml @startuml !theme toy participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with toy theme

@startuml @startuml !theme toy state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with toy theme

@startuml @startuml !theme toy robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with toy theme

@startuml @startwbs !theme toy * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme united

Activity with united theme

@startuml @startuml !theme united start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with united theme

@startuml @startuml !theme united abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with united theme

@startuml @startuml !theme united actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with united theme

@startuml @startuml !theme united [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with united theme

@startuml @startmindmap !theme united + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with united theme

@startuml @startuml !theme united nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with united theme

@startuml @startuml !theme united object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with united theme

@startuml @startsalt !theme united {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with united theme

@startuml @startuml !theme united participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with united theme

@startuml @startuml !theme united state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with united theme

@startuml @startuml !theme united robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with united theme

@startuml @startwbs !theme united * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme vibrant

Activity with vibrant theme

@startuml @startuml !theme vibrant start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with vibrant theme

@startuml @startuml !theme vibrant abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with vibrant theme

@startuml @startuml !theme vibrant actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with vibrant theme

@startuml @startuml !theme vibrant [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with vibrant theme

@startuml @startmindmap !theme vibrant + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with vibrant theme

@startuml @startuml !theme vibrant nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with vibrant theme

@startuml @startuml !theme vibrant object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with vibrant theme

@startuml @startsalt !theme vibrant {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with vibrant theme

@startuml @startuml !theme vibrant participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with vibrant theme

@startuml @startuml !theme vibrant state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with vibrant theme

@startuml @startuml !theme vibrant robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with vibrant theme

@startuml @startwbs !theme vibrant * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme superhero

Activity with superhero theme

@startuml @startuml !theme superhero start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with superhero theme

@startuml @startuml !theme superhero abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with superhero theme

@startuml @startuml !theme superhero actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with superhero theme

@startuml @startuml !theme superhero [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with superhero theme

@startuml @startmindmap !theme superhero + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with superhero theme

@startuml @startuml !theme superhero nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with superhero theme

@startuml @startuml !theme superhero object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with superhero theme

@startuml @startsalt !theme superhero {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with superhero theme

@startuml @startuml !theme superhero participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with superhero theme

@startuml @startuml !theme superhero state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with superhero theme

@startuml @startuml !theme superhero robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with superhero theme

@startuml @startwbs !theme superhero * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme superhero-outline

Activity with superhero-outline theme

@startuml @startuml !theme superhero-outline start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with superhero-outline theme

@startuml @startuml !theme superhero-outline abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with superhero-outline theme

@startuml @startuml !theme superhero-outline actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with superhero-outline theme

@startuml @startuml !theme superhero-outline [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with superhero-outline theme

@startuml @startmindmap !theme superhero-outline + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with superhero-outline theme

@startuml @startuml !theme superhero-outline nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with superhero-outline theme

@startuml @startuml !theme superhero-outline object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with superhero-outline theme

@startuml @startsalt !theme superhero-outline {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with superhero-outline theme

@startuml @startuml !theme superhero-outline participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with superhero-outline theme

@startuml @startuml !theme superhero-outline state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with superhero-outline theme

@startuml @startuml !theme superhero-outline robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with superhero-outline theme

@startuml @startwbs !theme superhero-outline * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme reddress-darkblue

Activity with reddress-darkblue theme

@startuml @startuml !theme reddress-darkblue start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with reddress-darkblue theme

@startuml @startuml !theme reddress-darkblue abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with reddress-darkblue theme

@startuml @startuml !theme reddress-darkblue actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with reddress-darkblue theme

@startuml @startuml !theme reddress-darkblue [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with reddress-darkblue theme

@startuml @startmindmap !theme reddress-darkblue + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with reddress-darkblue theme

@startuml @startuml !theme reddress-darkblue nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with reddress-darkblue theme

@startuml @startuml !theme reddress-darkblue object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with reddress-darkblue theme

@startuml @startsalt !theme reddress-darkblue {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with reddress-darkblue theme

@startuml @startuml !theme reddress-darkblue participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with reddress-darkblue theme

@startuml @startuml !theme reddress-darkblue state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with reddress-darkblue theme

@startuml @startuml !theme reddress-darkblue robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with reddress-darkblue theme

@startuml @startwbs !theme reddress-darkblue * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme reddress-darkorange

Activity with reddress-darkorange theme

@startuml @startuml !theme reddress-darkorange start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with reddress-darkorange theme

@startuml @startuml !theme reddress-darkorange abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with reddress-darkorange theme

@startuml @startuml !theme reddress-darkorange actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with reddress-darkorange theme

@startuml @startuml !theme reddress-darkorange [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with reddress-darkorange theme

@startuml @startmindmap !theme reddress-darkorange + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with reddress-darkorange theme

@startuml @startuml !theme reddress-darkorange nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with reddress-darkorange theme

@startuml @startuml !theme reddress-darkorange object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with reddress-darkorange theme

@startuml @startsalt !theme reddress-darkorange {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with reddress-darkorange theme

@startuml @startuml !theme reddress-darkorange participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with reddress-darkorange theme

@startuml @startuml !theme reddress-darkorange state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with reddress-darkorange theme

@startuml @startuml !theme reddress-darkorange robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with reddress-darkorange theme

@startuml @startwbs !theme reddress-darkorange * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme reddress-darkred

Activity with reddress-darkred theme

@startuml @startuml !theme reddress-darkred start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with reddress-darkred theme

@startuml @startuml !theme reddress-darkred abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with reddress-darkred theme

@startuml @startuml !theme reddress-darkred actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with reddress-darkred theme

@startuml @startuml !theme reddress-darkred [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with reddress-darkred theme

@startuml @startmindmap !theme reddress-darkred + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with reddress-darkred theme

@startuml @startuml !theme reddress-darkred nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with reddress-darkred theme

@startuml @startuml !theme reddress-darkred object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with reddress-darkred theme

@startuml @startsalt !theme reddress-darkred {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with reddress-darkred theme

@startuml @startuml !theme reddress-darkred participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with reddress-darkred theme

@startuml @startuml !theme reddress-darkred state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with reddress-darkred theme

@startuml @startuml !theme reddress-darkred robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with reddress-darkred theme

@startuml @startwbs !theme reddress-darkred * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme reddress-lightblue

Activity with reddress-lightblue theme

@startuml @startuml !theme reddress-lightblue start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with reddress-lightblue theme

@startuml @startuml !theme reddress-lightblue abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with reddress-lightblue theme

@startuml @startuml !theme reddress-lightblue actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with reddress-lightblue theme

@startuml @startuml !theme reddress-lightblue [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with reddress-lightblue theme

@startuml @startmindmap !theme reddress-lightblue + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with reddress-lightblue theme

@startuml @startuml !theme reddress-lightblue nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with reddress-lightblue theme

@startuml @startuml !theme reddress-lightblue object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with reddress-lightblue theme

@startuml @startsalt !theme reddress-lightblue {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with reddress-lightblue theme

@startuml @startuml !theme reddress-lightblue participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with reddress-lightblue theme

@startuml @startuml !theme reddress-lightblue state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with reddress-lightblue theme

@startuml @startuml !theme reddress-lightblue robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with reddress-lightblue theme

@startuml @startwbs !theme reddress-lightblue * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme reddress-lightgreen

Activity with reddress-lightgreen theme

@startuml @startuml !theme reddress-lightgreen start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Theme reddress-lightgreen

Class with reddress-lightgreen theme

@startuml @startuml !theme reddress-lightgreen abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with reddress-lightgreen theme

@startuml @startuml !theme reddress-lightgreen actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with reddress-lightgreen theme

@startuml @startuml !theme reddress-lightgreen [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with reddress-lightgreen theme

@startuml @startmindmap !theme reddress-lightgreen + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with reddress-lightgreen theme

@startuml @startuml !theme reddress-lightgreen nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with reddress-lightgreen theme

@startuml @startuml !theme reddress-lightgreen object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with reddress-lightgreen theme

@startuml @startsalt !theme reddress-lightgreen {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with reddress-lightgreen theme

@startuml @startuml !theme reddress-lightgreen participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with reddress-lightgreen theme

@startuml @startuml !theme reddress-lightgreen state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with reddress-lightgreen theme

@startuml @startuml !theme reddress-lightgreen robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with reddress-lightgreen theme

@startuml @startwbs !theme reddress-lightgreen * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme reddress-lightorange

Activity with reddress-lightorange theme

@startuml @startuml !theme reddress-lightorange start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with reddress-lightorange theme

@startuml @startuml !theme reddress-lightorange abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with reddress-lightorange theme

@startuml @startuml !theme reddress-lightorange actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with reddress-lightorange theme

@startuml @startuml !theme reddress-lightorange [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with reddress-lightorange theme

@startuml @startmindmap !theme reddress-lightorange + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with reddress-lightorange theme

@startuml @startuml !theme reddress-lightorange nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with reddress-lightorange theme

@startuml @startuml !theme reddress-lightorange object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with reddress-lightorange theme

@startuml @startsalt !theme reddress-lightorange {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with reddress-lightorange theme

@startuml @startuml !theme reddress-lightorange participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with reddress-lightorange theme

@startuml @startuml !theme reddress-lightorange state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with reddress-lightorange theme

@startuml @startuml !theme reddress-lightorange robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with reddress-lightorange theme

@startuml @startwbs !theme reddress-lightorange * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Theme reddress-lightred

Activity with reddress-lightred theme

@startuml @startuml !theme reddress-lightred start :init; -> test of color; if (color?) is (<color:red>red) then :print red; else :print not red; note right: no color endif partition End { :end; } -> this is the end; end @enduml @enduml

Class with reddress-lightred theme

@startuml @startuml !theme reddress-lightred abstract abstract abstract class "abstract class" annotation annotation circle circle () circle_short_form class class diamond diamond <> diamond_short_form entity entity enum enum interface interface @enduml @enduml

Deployment with reddress-lightred theme

@startuml @startuml !theme reddress-lightred actor actor actor/ "actor/" agent agent artifact artifact boundary boundary card card circle circle cloud cloud collections collections component component control control database database entity entity file file folder folder frame frame hexagon hexagon interface interface label label node node package package person person queue queue rectangle rectangle stack stack storage storage usecase usecase usecase/ "usecase/" @enduml @enduml

Gantt with reddress-lightred theme

@startuml @startuml !theme reddress-lightred [Task1] lasts 20 days note bottom memo1 ... memo2 ... explanations1 ... explanations2 ... end note [Task2] lasts 4 days [Task1] -> [Task2] -- Separator title -- [M1] happens on 5 days after [Task1]'s end -- end -- @enduml @enduml

Mindmap with reddress-lightred theme

@startuml @startmindmap !theme reddress-lightred + root **:right_1.1 right_1.2; ++ right_2 left side -- left_1 -- left_2 **:left_3.1 left_3.2; @endmindmap @enduml

Nwdiag with reddress-lightred theme

@startuml @startuml !theme reddress-lightred nwdiag { network DMZ { address = "y.x.x.x/24" web01 [address = "y.x.x.1"]; web02 [address = "y.x.x.2"]; } network Internal { web01; web02; db01 [address = "w.w.w.z", shape = database]; } group { description = "long group label"; web01; web02; db01; } } @enduml @enduml

Object with reddress-lightred theme

@startuml @startuml !theme reddress-lightred object user1 user1 : name = "Dummy" user1 : id = 123 object user2 { name = "Dummy" id = 123 } object o1 object o2 diamond dia object o3 o1 --> dia o2 --> dia dia --> o3 @enduml @enduml

Salt with reddress-lightred theme

@startuml @startsalt !theme reddress-lightred {+ Just plain text [This is my button] () Unchecked radio (X) Checked radio [] Unchecked box [X] Checked box "Enter text here " ^This is a droplist^ } @endsalt @enduml

Sequence with reddress-lightred theme

@startuml @startuml !theme reddress-lightred participant Participant as Foo actor Actor as Foo1 boundary Boundary as Foo2 control Control as Foo3 entity Entity as Foo4 database Database as Foo5 collections Collections as Foo6 queue Queue as Foo7 Foo -> Foo1 : To actor Foo -> Foo2 : To boundary Foo -> Foo3 : To control Foo -> Foo4 : To entity Foo -> Foo5 : To database Foo -> Foo6 : To collections Foo -> Foo7: To queue @enduml @enduml

State with reddress-lightred theme

@startuml @startuml !theme reddress-lightred state choice1 <<choice>> state fork1 <<fork>> state join2 <<join>> state end3 <<end>> [*] --> choice1 : from start\nto choice choice1 --> fork1 : from choice\nto fork choice1 --> join2 : from choice\nto join choice1 --> end3 : from choice\nto end fork1 ---> State1 : from fork\nto state fork1 --> State2 : from fork\nto state State2 --> join2 : from state\nto join State1 --> [*] : from state\nto end join2 --> [*] : from join\nto end @enduml @enduml

Timing with reddress-lightred theme

@startuml @startuml !theme reddress-lightred robust "Web Browser" as WB concise "Web User" as WU WB is Initializing WU is Absent @WB 0 is idle +200 is Processing +100 is Waiting WB@0 <-> @50 : {50 ms lag} @WU 0 is Waiting +500 is ok @200 <-> @+150 : {150 ms} @enduml @enduml

WBS with reddress-lightred theme

@startuml @startwbs !theme reddress-lightred * World ** America ***_ Canada ***_ Mexico ***_ USA ** Europe ***_ England ***_ Germany ***_ Spain @endwbs @enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown

🚧 Under construction...

• All activity
• Object
• Timing
• Network (nwdiag)
• Salt
• Archimate
• Gantt
• JSON/YAML
• Git/Wire/...