Plant Text
Generate UML diagrams from text. Sequence, class, use case, activity, and component diagrams.
Open the official app on www.planttext.com
This tool is hosted by its maintainers. Click below to open www.planttext.com in a new tab — it's their official demo.
Browse diagram tools →What's next with Plant Text?
Choose how you want to get started.
Use it free
Open the official tool or demo — no account needed.
Self-host it
Run the open-source version on your own infrastructure.
What is Plant Text?
PlantText is an open-source web application licensed under the MIT license that converts structured text syntax into Unified Modeling Language (UML) diagrams. It addresses the overhead of traditional graphical editing tools by decoupling diagram content from visual presentation. Software developers, system architects, and technical writers use PlantText to build maintainable system models that reside directly alongside application source code in version control systems like Git. The editor takes plain text written in PlantUML markup as input and passes it to rendering engines to generate structured visual outputs. These outputs include vector formats such as Scalable Vector Graphics (SVG) or bitmap formats like Portable Network Graphics (PNG). By automating layout calculation, PlantText ensures that diagrams remain geometrically balanced without requiring manual positioning of individual elements. First, PlantText processes sequence diagrams to model dynamic interaction patterns over time between actors and components, automatically calculating vertical lifelines and message arrow alignment. Second, it generates structural class diagrams, translating attributes, method signatures, inheritance relationships, and interface implementations into standard UML notation. Third, it renders activity and use case diagrams, converting branch logic, decision nodes, and system boundary interactions into execution flowcharts. Compared to visual design suites like Visio or Lucidchart, PlantText relies on deterministic layout algorithms rather than freeform drag-and-drop mechanics. This design guarantees that two developers compiling the same text definition will output identical visual diagrams, preventing style drift across documentation sets.
How it works
When text is entered into PlantText, the application parses the input string to locate markup delimiters such as `@startuml` and `@enduml`. The internal parser constructs an Abstract Syntax Tree (AST) representing every entity, relation, stereotype, and style directive. This AST is then transformed into an encoded string format using a custom text compression workflow. To illustrate this pipeline, consider a simple two-line sequence input: `Alice -> Bob: HTTP 200 OK`. The parser identifies two participant nodes (`Alice` and `Bob`) and an execution arrow annotated with payload text. PlantText compresses this script using a combination of DEFLATE compression and a modified Base64 encoding scheme. The compressed string is appended to a rendering endpoint URL, which evaluates the graph hierarchy via Graphviz dot algorithms to yield a formatted SVG image. The front-end client utilizes the CodeMirror text editor component to offer syntax highlighting and code editing capabilities directly within modern web browsers. Rendering tasks rely on interactions with a PlantUML server engine, which processes the encoded diagram parameters and translates structural syntax into graphical primitives using Java libraries and the Graphviz layout utility. Because image rendering involves network transport to compile compressed strings into graphic assets, system architects working with sensitive diagrams should evaluate data flow routes. The open-source nature of the project allows engineering teams to host dedicated server instances within private network boundaries to satisfy compliance standards.
How to use it
- 1First, navigate to the editor window and select the default template or clear the workspace. Second, type the opening directive `@startuml` on line 1 and the closing directive `@enduml` on line 5 to define the compilation boundary. Third, declare participants on line 2 by entering `actor User` and `database PostgreSQL` to register system nodes.
- 2Fourth, define interaction vectors on lines 3 and 4 by writing `User -> PostgreSQL: SELECT * FROM users` followed by `PostgreSQL --> User: 200 OK (Data Record)`. Fifth, click the Refresh button or press Ctrl+Enter to render the syntax into an SVG diagram. Sixth, click the Export button to save the generated visual asset as a PNG image or copy the generated image URL into your repository README.
- 3A frequent error occurs when developers omit closing tokens like `@enduml` or mismatched curly braces in class definitions, resulting in server-side parsing exceptions. Another common mistake is manually specifying precise pixel positions, which overrides the automated graph optimization engine and leads to overlapping text blocks.
- 4To optimize visual clarity in complex system maps, use the `skinparam` directive to standardize custom fill colors and font parameters across diagrams. Additionally, group related services into logical clusters using the `package` or `rectangle` syntax blocks to prevent wide, unstructured diagram layouts.
What it can do
- Generation
Use cases
Assumptions and limitations
Assumptions
- source: https://github.com/planttext
- license: MIT — free to use
- privacy: Opens an external demo
Limitations
- PlantText relies on standard PlantUML syntax rules, which do not support direct CSS style overrides, meaning visual styling is restricted to skinparam parameters; developers requiring custom vector branding must export SVG files into vector editing suites like Inkscape.
- Rendering large architectural diagrams exceeding 500 graph nodes causes Graphviz layout calculation delays, leading to browser request timeouts; engineers modeling enterprise systems must split large diagrams into smaller sub-component views.
- The default web interface transmits encoded diagram text across external HTTP requests to a rendering server endpoint, presenting data governance risks for proprietary internal architectures; enterprise security teams must deploy self-hosted instances from the open-source repository.
- Syntax error feedback returned from the parsing engine lacks precise line-number pinpointing, causing debugging delays on long code blocks; users must validate complex diagrams by incrementally compiling small snippets.
Understanding the result
Generate UML diagrams from text. Sequence, class, use case, activity, and component diagrams.
Tool details
- Clearly flagged when a network request is needed.
- No account, no sign-up, and no tracking of your content.
- Powered by planttext (MIT).
- Built with
- planttext (https://github.com/planttext)
- License
- MIT
- Runs locally
- No — requires a network request
- Verification
- Not yet verified
- Input
- Text
- Output
- Generated Output
Built with https://github.com/planttext. OpenToolVault provides the discovery and browser interface while crediting the original project maintainers.
- Built with
- planttext
- License
- MIT
Open-source project
OpenToolVault is an independent directory. We are not affiliated with or endorsed by this project.
References
- /planttext — GitHub Repository
Upstream project · GitHub
- MIT License
Upstream project
Frequently asked
How do I create a sequence diagram using PlantText?
To create a sequence diagram, open the editor and enclose your markup between `@startuml` and `@enduml` tags. Define participants using keywords like `actor Client` and `participant API`. Add message flows using arrows such as `Client -> API: GET /v1/resource` and response lines like `API --> Client: 200 OK`. Press the refresh button to trigger the layout engine, which parses the sequence logic and calculates object lifelines automatically. You can then download the output as a PNG or SVG asset.
How does PlantText convert plain text code into rendered UML images under the hood?
PlantText reads text syntax entered into its web editor and parses the structure into an internal tree of graph nodes and edges. It converts this string payload into a compressed DEFLATE byte array, which is encoded using a modified Base64 alphabet to generate an alphanumeric key. This key is sent via HTTP GET or POST requests to a PlantUML rendering engine. The server engine processes the layout using Graphviz dot algorithms, rendering the node relationships into SVG primitives or PNG bitmaps returned directly to the browser client.
How do I export high-resolution PNG or SVG diagrams from PlantText?
After compiling your text syntax into a visual diagram in the workspace viewer, locate the export control bar beneath the image display pane. Select SVG format if you require scalable vector graphics for print or responsive web scaling, or choose PNG format for standard documentation embeds. The application processes the request by generating a direct download stream from the compiled image buffer. If you require programmatic embedding, copy the generated image URL directly into your Markdown files to render dynamic vector assets upon repository loading.