umlet.com

UMLet exports diagrams to EPS, PDF, JPG, SVG, and the system clipboard, and version 15.0 added high-resolution export. The fastest sharing path is pressing C to copy the current diagram straight to the clipboard; the file formats are better when you need to embed a diagram in a document or hand it to someone who doesn't use UMLet.

Export formats at a glance

High-resolution export was introduced in UMLet 15.0, so if crisp output matters, use a 15.0-or-later build rather than an older one.

Copy a diagram to the clipboard

This is the option to reach for when the diagram is going into a chat, a ticket, or another editor right now.

1. Open or create the diagram in UMLet.
2. Make sure the diagram canvas has focus (click on it if needed).
3. Press C.

Expected result: the diagram is copied to the system clipboard, and you can paste it into whatever application you're using. No file is written to disk, which is why this is the quickest route for casual sharing.

Export to a file

Use a file export when the diagram needs to live somewhere durable or be embedded in a document.

1. Build the diagram on the canvas.
2. Use the export function and choose EPS, PDF, JPG, or SVG.
3. Save the file and open it in the target application to confirm it looks right.

The site lists these four formats as the export set; it does not document per-format settings such as DPI or page size, so treat the exact output options as something to check in your installed version.

Choosing between clipboard and file export

• Clipboard (C) — fastest, no file management, ideal for pasting into a message or a document you're already editing.
• SVG or EPS — pick these when the diagram will be scaled, printed, or edited further as vector art.
• PDF — pick this when the recipient just needs to view or print it without editing.
• JPG — pick this for a lightweight raster image where scaling isn't a concern.

Practical notes

• The site's quickstart lists C for clipboard copy, +/- or Ctrl+mousewheel for zoom, and Shift to avoid sticking relations — zooming before you export or copy affects what you capture, so frame the diagram first.
• UMLet is described as free and open-source, with a stand-alone app for Windows, macOS, and Linux, an Eclipse plugin, a web app (UMLetino), and a Visual Studio Code extension. Export behavior may differ slightly between these builds, so verify the format you need in the one you actually use.
• The site mentions sponsorship via GitHub, Patreon, and PayPal, but that is unrelated to export or sharing features.

UMLet is a free, open-source UML tool built for fast UML sketching. Its defining idea is that you modify UML elements through text input and a small markdown-like dialect instead of pop-up dialogs. It runs as a stand-alone app on Windows, macOS, and Linux, as an Eclipse plugin, as a web app called UMLetino, and as a Visual Studio Code extension. If you want to draw UML diagrams quickly without fighting dialog boxes, UMLet is aimed at you; if you need a full model-driven tool with a repository and code generation, it is not that.

What UMLet is for

UMLet targets quick, lightweight UML sketches rather than heavyweight modeling. The current release shown on the site is UMLet 15.1, described as a "Free UML Tool for Fast UML Diagrams."

Supported diagram types include:

• Class diagrams
• Use case diagrams
• Sequence diagrams
• State diagrams
• Deployment diagrams
• Activity diagrams

Sequence and activity diagrams can be created from plain text, which fits the tool's text-first approach.

How the text-based editing works

Instead of opening a properties dialog for each element, you select an element and edit it in the lower-right text panel using a small markdown dialect. This is the core concept the project describes in a paper.

The practical consequences:

• Speed: you type changes rather than click through dialogs.
• Templates: elements can be modified inside their palettes and immediately reused as new templates, so you can tailor UMLet to your modeling needs.
• Custom elements: you can create your own UML elements. An element's look can be changed at run-time by editing a few lines of Java code, which UMLet compiles on the fly, so new element types can be added without leaving the tool.

Quickstart

The site's own quickstart lists these operations:

1. Add elements to a diagram with a double click.
2. Edit elements using the lower-right text panel.
3. Use Ctrl+Space for context-sensitive help.
4. Select multiple elements using Ctrl or a lasso.
5. Press C to copy the diagram to the system clipboard.
6. Use +/- or Ctrl+mousewheel to zoom.
7. Press Shift to avoid sticking relations.

The expected result is a diagram you can assemble and adjust entirely from the canvas plus the text panel, without modal dialogs.

Sharing and export

Diagrams can be exported to EPS, PDF, JPG, SVG, and the clipboard. Version 15.0 added hi-res export, along with web zoom, lasso, export, dark mode, and startup changes. Version 15.1 included a relation bug fix, a log library update, and dark mode cleanup.

Where you can run it

Cost and licensing

UMLet is described as free and open-source. The site links to its GitHub repository and offers sponsorship via GitHub, Patreon, or PayPal. Sponsorship is optional support for the project, not a purchase requirement.

When to choose something else

UMLet fits fast sketching and text-driven editing. If your work depends on a shared model repository, round-trip code generation, or team-wide model governance, those needs point to a different class of tool. For quick diagrams, custom elements, and script-like editing, UMLet's combination of a simple UI and text input is the reason to pick it.

Download UMLet 15.1 as a stand-alone app for Windows, macOS, or Linux, or use it as an Eclipse plugin, a Visual Studio Code extension, or the web app UMLetino — then draw your first diagram by double-clicking to add elements and editing them in the lower-right text panel. This quickstart suits anyone who wants fast UML sketches without pop-up dialogs; the trade-off is that element editing happens through text and a small markdown dialect rather than a graphical property editor. UMLet is described as a free, open-source UML tool.

Choose how you want to run UMLet

The site also links to the GitHub repository (github.com/umlet) and lists contact addresses ([email protected]) and a Twitter handle (@twumlet). If you want to support the project, the site mentions sponsoring via GitHub, Patreon, or PayPal.

Draw your first diagram

1. Add an element — double-click to add elements to a UML diagram.
2. Edit the element — use the lower-right text panel. Elements are modified through text input and a small markdown dialect instead of pop-up dialogs.
3. Get help while typing — press Ctrl+Space for context-sensitive help.
4. Select multiple elements — use Ctrl or a lasso selection.
5. Copy the diagram — press 'C' to copy it to the system clipboard.
6. Zoom — use +/- or Ctrl+mousewheel.
7. Avoid sticking relations — press Shift.

The expected result after these steps is a diagram you can keep editing in text form and export when ready.

Export and share

UMLet exports to eps, pdf, jpg, svg, and the clipboard. Version 15.0 added hi-res export, so if you need a sharper image, that capability is available in current releases.

Reuse and customize elements

• Elements can be modified inside their palettes and immediately used as new templates, so you can tailor UMLet to your modeling needs.
• You can create your own custom UML elements. An element's look can be modified at run-time by changing a few lines of Java code, and UMLet compiles the new element's code on the fly — without leaving UMLet.
• Learning about element features is supported by prototypically using them from sample palettes.

Supported diagram types

UMLet supports class diagrams, use case diagrams, sequence diagrams, state diagrams, deployment diagrams, and activity diagrams. The site points to sample diagrams and examples for each.

What changed recently

• 15.1 — relation bug fix, log lib update, dark mode cleanup.
• 15.0 — web zoom, lasso, export, dark mode; hi-res export; startup improvements.
• 14.3 — improved OS and Eclipse integration; XML security fix.

Common sticking points

• Editing feels unusual at first — this is by design: UMLet uses text input and a small markdown dialect rather than dialogs. Use Ctrl+Space when unsure.
• Relations stick when you don't want them to — hold Shift.
• You need a different runtime — if the stand-alone app doesn't fit your workflow, the Eclipse plugin, VS Code extension, or UMLetino web app are alternatives listed on the site.

For bugs or requests, the site suggests creating a code ticket or emailing [email protected].

Yes. UMLet lets you create your own custom UML elements, and you can do it without leaving the application. The mechanism is unusual: instead of drawing shapes with a mouse, you modify an element's appearance at run time by changing a few lines of Java code, and UMLet compiles that code on the fly. This makes custom elements practical if you are comfortable editing small amounts of code, and unnecessary if you only need standard UML notation.

How custom elements work

UMLet's core design is that elements are defined by text rather than pop-up dialogs. Each element has a text panel where you edit its content using a small markdown-like dialect, and its drawing behavior comes from Java code attached to the element.

For custom elements, the workflow is:

1. Take an existing element as a starting point.
2. Change a few lines of its Java code to alter how it is drawn.
3. UMLet compiles the new code immediately, so the element updates at run time.
4. The new element type becomes available to add to your diagrams.

Because the compilation happens inside UMLet, you do not need a separate build step, an external IDE, or a restart to see the result.

Two ways to extend UMLet

There are two distinct levels of customization, and they suit different needs.

The palette route is the lighter option: you can modify elements inside their palettes and immediately use them as new templates. This lets you tailor UMLet to your modeling needs without writing code, as long as the change can be expressed through the element's text and existing drawing behavior.

The code route is for genuinely new element types. Since an element's look is modified at run time by changing a few lines of Java, you can create and add new element types to your diagrams entirely within UMLet.

What you can model

UMLet supports a range of UML diagram types, so custom elements sit alongside standard notation rather than replacing it:

• Class diagrams
• Use case diagrams
• Sequence diagrams
• State diagrams
• Deployment diagrams
• Activity diagrams

Sequence and activity diagrams can also be created from plain text, which fits the same text-first philosophy as custom elements.

When custom elements are worth it

Custom elements make sense when your modeling needs go beyond what the built-in palettes offer — for example, domain-specific notation, house styles for a team, or repeated diagram patterns you want to standardize as reusable templates.

They are less useful if you only produce standard UML diagrams occasionally. In that case, the built-in elements and the palette-modification route cover most needs, and you avoid maintaining Java code.

One practical note: because custom elements depend on Java code compiled at run time, treat them as part of your modeling setup rather than throwaway tweaks — if you rely on them across projects, keep track of the code you wrote.

Getting the tool

UMLet is described as a free, open-source UML tool. It is available as a stand-alone app for Windows, macOS, and Linux, as an Eclipse plugin, as a web app called UMLetino, and as a Visual Studio Code extension. The current version referenced on the site is UMLet 15.1.

UMLet ships in four forms, and the right one depends on where you already work. Choose the stand-alone app if you want the full feature set on Windows, macOS, or Linux without an IDE; the Eclipse plugin if you model inside Eclipse; the web app (UMLetino) if you need a diagram fast without installing anything; and the VS Code extension if Visual Studio Code is your editor. All four share the same core idea — you edit UML elements as text rather than through pop-up dialogs — so the choice is mostly about environment, not diagram capability.

The four options at a glance

Stand-alone app

This is the reference version. The site calls it the "full-featured UMLet as stand-alone app for Windows, macOS, and Linux," which makes it the default choice when you don't have a strong reason to stay inside an IDE.

Pick it if you want the complete toolset — custom elements, the full export range, and the sample palettes — in one place. The trade-off is that it's a separate program, so you switch windows instead of drawing next to your code.

Eclipse plugin

Choose this if Eclipse is already your development environment. The plugin keeps diagrams inside the IDE, so you avoid context-switching between a project and a separate diagramming tool.

The site notes that version 14.3 improved "OS and Eclipse integration," so the plugin has received specific attention rather than being an afterthought. If you live in Eclipse, this is the natural fit.

Web app (UMLetino)

UMLetino is the browser version, and it's the right pick when installation isn't an option — a locked-down machine, a quick diagram on someone else's computer, or a sketch you want to share without a file.

It has grown more capable over time. Version 15.0 added zoom, lasso selection, export, dark mode, hi-res export, and startup improvements. That covers most sketching needs, though a browser tool is generally the lighter option compared with the stand-alone app.

VS Code extension

Use this if Visual Studio Code is your editor. It puts UMLet's text-driven element editing inside the editor you already have open, which suits developers who want diagrams to live alongside source files.

The extension is listed on the VS Code Marketplace, and the site invites users to "star it" there — a small signal that it's actively maintained rather than abandoned.

What's the same across all four

The core workflow doesn't change with the version:

• Add elements with a double click.
• Edit elements in the lower-right text panel, using a small markdown-like dialect instead of dialogs.
• Get help with Ctrl+Space for context-sensitive assistance.
• Select multiple elements with Ctrl or a lasso.
• Copy to clipboard by pressing C.
• Zoom with +/− or Ctrl+mousewheel.
• Hold Shift to avoid sticking relations.

Diagram type support is also shared: class, use case, sequence, state, deployment, and activity diagrams. Custom elements — where you change a few lines of Java and UMLet compiles the new element on the fly — are part of the tool's design, so if that's your reason for using UMLet, confirm the specific version supports the workflow you need before committing.

How to decide

• No IDE preference, want everything: stand-alone app.
• Work in Eclipse: Eclipse plugin.
• Can't or don't want to install: UMLetino in the browser.
• Work in VS Code: VS Code extension.

If you're unsure, start with the stand-alone app to learn the text-editing workflow, then move to the plugin or extension that matches your daily environment. The skills transfer directly because the element syntax is the same.

A note on cost and support

The site describes UMLet as "a free, open-source UML tool." It also lists sponsorship options via GitHub, Patreon, and PayPal, and provides contact at [email protected] plus a code ticket system for bugs and requests. Sponsorship is optional support for the project, not a paid tier — the page presents the tool itself as free and open-source.