A PlantUML sequence diagram shows how objects interact with each other over time in a specific scenario. It is the most commonly used UML diagram type in computer science courses and software engineering assignments. The PlantUML sequence diagram online editor above lets you write your scenario in plain text and renders the diagram instantly.

Sequence diagrams are used to model processes like user login flows, API request-response cycles, payment processing, and any system interaction that has a defined order of steps. The plant text UML syntax for sequence diagrams is one of the simplest to learn — arrows between participants represent messages.

@startuml
title Login System
actor User
participant Browser
participant Server
participant Database

User -> Browser : Enter credentials
Browser -> Server : POST /login
Server -> Database : Validate user
Database --> Server : User found
Server --> Browser : Session token
Browser --> User : Dashboard
@enduml

Key syntax: Use -> for solid arrows, --> for dashed return arrows, ->> for async messages. Wrap groups with alt/else/end for conditional flows. Use activate and deactivate to show object lifelines.

The PlantUML class diagram models the structure of a system by showing its classes, attributes, methods, and the relationships between them. It is fundamental to object-oriented programming courses and is used in almost every software engineering assignment that involves system design. Our free PlantUML diagram generator renders class diagrams instantly from text.

Class diagrams support inheritance (--|>), implementation (..|>), association (-->), aggregation (o--), and composition (*--) relationships. Visibility is indicated by + public, - private, # protected, and ~ package.

@startuml
class Animal {
  +name: String
  +age: int
  +speak(): void
}
class Dog {
  +breed: String
  +fetch(): void
}
class Cat {
  +indoor: boolean
  +purr(): void
}
Animal <|-- Dog
Animal <|-- Cat
@enduml

Student tip: Always start with identifying your classes, then list attributes and methods, then draw relationships. The PlantUML online editor above will immediately show you if your class structure makes visual sense before you submit your assignment.

A PlantUML use case diagram describes the functional requirements of a system from the user’s perspective. It shows actors (users or external systems) and the use cases (actions) they can perform. Use case diagrams are widely used in requirements engineering courses, systems analysis, and software project documentation.

In our free PlantUML diagram online generator, use case diagrams use actor to define users, usecase or parentheses (Use Case Name) for actions, and rectangle to draw system boundaries. Relationships between use cases use .> for include and extend relationships.

@startuml
actor Student
actor Admin

rectangle "University Portal" {
  usecase (Register Course)
  usecase (View Grades)
  usecase (Pay Fees)
  usecase (Manage Users)
}

Student --> (Register Course)
Student --> (View Grades)
Student --> (Pay Fees)
Admin --> (Manage Users)
@enduml

A PlantUML flow diagram — also called an activity diagram — represents the flow of control or data through a system or process. It is similar to a traditional flowchart but follows UML notation. Activity diagrams are used for modeling algorithms, business processes, user journeys, and system workflows in software engineering and business analysis courses.

The PlantUML diagram online activity syntax uses :step name; for actions, start and stop for the initial and final nodes, if (condition?) then for decisions, and while (condition?) for loops. This makes it one of the most readable diagram-as-code formats available.

@startuml
start
:Student submits assignment;
if (Before deadline?) then (yes)
  :Accept submission;
  :Calculate grade;
  if (Grade >= 50?) then (pass)
    :Record pass;
  else (fail)
    :Record fail;
  endif
else (no)
  :Apply late penalty;
  :Accept with deduction;
endif
stop
@enduml

A PlantUML state diagram models the different states an object or system can be in, and the transitions between those states. State diagrams are used in automata theory, embedded systems design, protocol modeling, and UI behavior documentation. They are a standard deliverable in software engineering and systems programming courses.

State diagrams in our PlantUML viewer use [*] for the initial and final states, state names for nodes, and arrows with --> for transitions. You can add transition triggers and guard conditions after a colon on the transition line.

@startuml
[*] --> Idle

Idle --> Processing : submit()
Processing --> Success : validate() OK
Processing --> Error : validate() fails
Error --> Idle : reset()
Success --> [*]
@enduml

A PlantUML ER diagram — also called a PlantUML database diagram — models the data structure of a system by showing entities (tables), their attributes (columns), and the relationships between them. ER diagrams are a required deliverable in almost every database design course at university level.

PlantUML supports ER diagrams using the entity keyword with attributes listed inside. Relationships use crow’s foot notation: ||--o{ for one-to-many, ||--|| for one-to-one, and }o--o{ for many-to-many. Our free PlantUML diagram online free tool renders these instantly.

@startuml
entity Student {
  * id : INT <>
  --
  name : VARCHAR
  email : VARCHAR
}
entity Course {
  * id : INT <>
  --
  title : VARCHAR
  credits : INT
}
entity Enrollment {
  * id : INT <>
  --
  student_id : INT <>
  course_id : INT <>
  grade : VARCHAR
}
Student ||--o{ Enrollment : "enrolls"
Course ||--o{ Enrollment : "has"
@enduml

PlantUML mind maps use the @startmindmap notation to create hierarchical brainstorming diagrams. Unlike other diagram types, mind maps are useful for any subject — not just computer science. Students use them for project planning, revision notes, essay structuring, and breaking down complex topics. Our PlantUML online server connection renders mind maps in the same panel as all other diagram types.

@startmindmap
* Database Systems
** Relational DB
*** Tables & Keys
*** SQL Queries
*** Normalization
** NoSQL
*** Document (MongoDB)
*** Key-Value (Redis)
** Design
*** ER Diagrams
*** Schema Design
@endmindmap