UML Wizard User Manual

UML Wizard draws class, sequence, state machine, activity, use case, component and deployment diagrams, organised in projects. It turns class diagrams into source code and source code into class diagrams, and exchanges diagrams with OpenAPI and PlantUML. It runs on Windows, macOS and Linux.

1. Getting started

When no project is open, for example when UML Wizard starts, the main area shows three cards:

• Create a New Project: asks for a name, author, description and the folder to create the project in (the projects folder of Preferences, else your Documents folder). The project gets a folder of its own, with its project file (.umlwiz) inside.
• Open an Existing Project: opens a project file. Projects from older versions (.umlproj) open too.
• Import Source Folder: creates a project with a class diagram of existing code; see Importing code.

The panel on the left lists your Recent Projects; click one to open it. A project file can also be passed on the command line, and is opened at start-up.

Once a project is open, create a diagram with the + button on the toolbar (or Diagram → New Diagram), pick a tool on the drawing toolbar and click the canvas.

New to UML? Help → Learn UML explains each kind of diagram and its notation.

2. The window

• Main toolbar: New Project, Open Project │ Save Project, + (new diagram of any type) │ Undo, Redo │ Cut, Copy, Paste │ Zoom out, zoom level, Zoom in, Actual size, Fit │ Edit, Font, Shape, Line (of the selected element) │ Bring to front, Bring forward, Send backward, Send to back (the selected node, note or text box). Buttons that do not apply are greyed out, e.g. Cut and Copy while nothing is selected.
• Drawing toolbar, between the tabs and the canvas: the tools of the diagram type, then, after a divider, Note, Attach Note and Text Box. Connector tools are shown as the connector they draw (line style and heads, with the first letter of a keyword such as «i» for «include»); hover a tool for its name.
• Project Explorer (left): the project's folders and diagrams. While no project is open it lists only the recent projects. Drag the edge between it and the tabs to resize it; View → Project Explorer (Ctrl+Alt+L) hides or shows it, and the choice is kept between runs.
• Tabs: one per open diagram. Drag a tab along the strip to reorder it, or click its ✕ to close it.

The Project Explorer and the tabs stay in step: activating a tab selects its diagram in the Project Explorer, and clicking a diagram in the Project Explorer opens it, or activates its tab when it is already open. Dragging a diagram to a folder does not open it, and selecting a diagram with the arrow keys leaves no tab active until Enter opens it.

On macOS the menus are in the window as on the other platforms, and the application menu in the menu bar (UML Wizard) has About UML Wizard and the standard items, including Quit (⌘Q).

3. Projects and diagrams

Projects

• File → New Project… creates a project folder and file; Open Project… opens one.
• Save Project (Ctrl+S, or the toolbar) writes the changes of every open diagram; it is enabled while there are unsaved changes. Save Project As… (Ctrl+Shift+S) writes the project, with its unsaved changes, to a new file, which becomes the project file.
• Creating, renaming, moving and deleting diagrams and folders, and changing properties, save the project at once.
• File → Project Properties… edits the name, version (your own, e.g. 1.2.0), description and author, and shows the folder of the project file: click it to copy it to the clipboard.
• File → Close Project closes it, asking to save unsaved changes first.
• Folder and file names made from project and diagram names work on Windows, macOS and Linux alike: characters any of them forbids (< > : " / \ | ? *) become _, so projects can be moved between them.

Recent projects

File → Recent Projects lists the 10 most recently opened or created projects, most recent first (Alt+F, P, then 1–9 or 0). While no project is open, the Project Explorer lists them too. A project that no longer exists can be removed from the list when you pick it; Clear Recent Projects empties the list.

Organising diagrams

• The + toolbar button (or Diagram → New Diagram) creates a diagram in the folder of the Project Explorer selection.
• File → New Folder… (or right-click the Project Explorer) creates a folder inside the selected folder.
• Drag diagrams and folders onto a folder to move them (or use Diagram → Move To…); drop them on empty space to move them to the top level. Drag a diagram above or below another to reorder them: a line shows where it goes.
• Diagram → Rename…, Move To… and Delete… act on the diagram selected in the Project Explorer; right-click the Project Explorer to rename, move or delete folders as well. Deleting a folder keeps its diagrams and subfolders and moves them up one level.

Diagram properties and tagged values

Select a diagram in the Project Explorer and choose Diagram → Properties… to edit its name, description, author and tagged values (name/value pairs). New diagrams take the project author. Classes, attributes and operations have tagged values too: in a class's Edit… dialog, the tag button next to the stereotype shows the class's, and the one on each attribute or operation row shows that member's. Rows without a name are dropped. Tagged values explains what they are for.

Tabs

Open diagrams, their order and the active tab are saved with the project and restored when it is opened. Diagram → Close All Diagrams closes every tab, asking to save unsaved changes first; the project stays open.

4. Drawing diagrams

Adding and connecting elements

• Add an element: pick a tool (Class, Lifeline, State, Action, Use Case, Component, …) and click the canvas.
• Connect elements: pick a relationship, message, transition, flow or other connector tool and drag from the source to the target. Invalid connections are refused, and the tool stays active so you can try again.
• Direction: arrow heads (inheritance, realization, dependency, directed association, transitions, flows, «include», «extend») point at the target. Aggregation and composition diamonds are drawn at the source: drag from the whole to the part.

Editing text

• Edit in place: double-click (or F2) a class name, attribute, operation, relationship label, lifeline, message, node name or edge label. Double-click the empty part of a class's attribute or operation compartment to add a member; Enter commits and starts the next member, Esc cancels. Clearing the text of a member deletes it.
• Edit dialogs: Edit… (Enter, Edit → Edit Element…, or right-click an element) opens the full editor: class members, visibility, static/abstract and kinds; relationship kinds and multiplicities; lifeline and message details; node names and edge labels; text, alignment and font of notes and text boxes.

Text typed in place uses UML notation:

Moving and resizing

Drag an element, or select it and press the arrow keys (1 unit; with Shift a 20-unit grid step). Drag the handle at the bottom-right of a selected element to resize it: classes in width, notes, text boxes and resizable nodes (states, actions, use cases, system boundaries, components, deployment nodes, devices, execution environments, artifacts, fork/join bars) in width and height. Lifelines move horizontally and messages vertically. A system boundary, node, device or execution environment takes the elements inside it along.

Clipboard and deleting

Cut, copy and paste elements with Ctrl+X, Ctrl+C and Ctrl+V, the toolbar or right-click. Elements paste into diagrams of their own type; notes and text boxes paste into any diagram. Right-click the background to paste at that point. Delete (⌫ on macOS) removes the selected element, and Undo (Ctrl+Z) and Redo (Ctrl+Y; ⌘⇧Z on macOS) step through every change.

Notes and text boxes

• Pick Note (a UML comment, drawn with a folded corner) or Text Box (a plain label) and click the canvas, then type. Enter starts a new line; Ctrl+Enter (⌘+Enter on macOS) or clicking elsewhere finishes. Text wraps to the width and is cut off at the edges. Edit… sets the text, horizontal alignment (left, center, right), vertical alignment (top, middle, bottom) and font.
• Pick Attach Note and drag from a note to the element it describes (or the other way round): a dashed line connects them and follows both when they move. Click the line to select it; Delete removes it. Deleting the note or the element removes its attachments.

Panning and zooming

Drag empty space, or use the middle button or the wheel, to pan. Ctrl+wheel (⌘+wheel on macOS), Ctrl+Plus, Ctrl+Minus, Ctrl+0 or the toolbar zoom; the zoom level button resets to 100 %, and Fit shows the whole diagram.

5. Formatting and arranging

Fonts

Select an element and choose Format → Font… (or the toolbar's Font button, or right-click it → Font…) to set its font family, size, bold and italic. Format → Diagram Font… (or right-click the background) sets the font of every element that has no font of its own. Class names stay bold and abstract elements italic whatever the font.

Fill and border

Select an element and choose Format → Shape… (or right-click it → Shape…) to set its fill colour, border colour and border thickness: click a colour's swatch to open the colour picker, or type #RRGGBB. Each part can stay on Default, the colour of the current scheme for that kind of element (blue classes, green interfaces, yellow notes, …), which follows the light or dark theme; custom colours are the same in both themes and in exports. Text on a custom fill turns dark or light, whichever reads better. Text boxes have no fill or border until they are given one.

The colour picker

Wherever UML Wizard asks for a colour, the swatch next to the #RRGGBB box opens the colour picker:

• On the left, click one of the 48 Basic colours, or one of your Custom colours; Add to Custom Colours adds the colour to them, and they are kept for the next time.
• On the right, click or drag in the spectrum to choose the hue (left to right) and saturation (top to bottom), and on the slider next to it to choose the brightness. The swatch below shows the colour.
• Or type the colour beside the swatch: as hue (degrees), saturation and value (percent), as red, green and blue (0–255), or as #RRGGBB in Hex.

OK uses the colour; Cancel keeps the one you had.

Line colour and thickness

Select a relationship, message or connector and choose Format → Line… (or right-click it → Line…) to set its colour and thickness, or keep Default (the scheme's line colour, thickness 1.3). Arrowheads, triangles and diamonds are drawn in the line's colour and thickness, and dashed lines keep their dashes in proportion. The toolbar has a button for each: Shape (paint bucket) for the selected shape and Line (line weights) for the selected connector.

Stacking order

Select a node (a class, lifeline, state, action, use case, component, deployment node, …), note or text box and use Format → Bring to Front (Ctrl+Shift+]), Bring Forward (Ctrl+]), Send Backward (Ctrl+[) or Send to Back (Ctrl+Shift+[), or the stacking buttons on the toolbar. Forward and backward pass the nearest overlapping node. Containers (system boundaries, deployment nodes, devices, execution environments) are stacked among themselves, always under the other nodes, and a container nested in another always stays above it. Notes and text boxes are stacked together, always above the UML elements.

Arrange Diagram

Format → Arrange Diagram (or right-click the background) rearranges the whole diagram so that it reads well, as one step that Undo takes back:

• Class diagrams are laid out in layers: base classes and interfaces above the classes that inherit from or realize them, wholes above their parts. Classes that nothing connects are packed in rows.
• State machine, activity, component and deployment diagrams read from top to bottom, and use case diagrams from left to right; nodes stay in the container they are in.
• Shapes in each layer are ordered to keep lines from crossing, and moved aside where a line would run through them.
• Sequence diagrams keep their message order: lifelines are ordered by the first message they take part in and spaced so every label fits.
• A title above the diagram stays above it; other notes and text boxes go in a column to the right, each note level with what it is attached to.

Only positions change (and the size of containers); connectors stay straight lines.

Theme

View → Theme switches between Light and Dark, or System (the default) to follow the operating system, also when it changes while UML Wizard runs. Diagrams are drawn in dark colours in dark mode; exported images always use the light colours. File → Preferences… also sets the theme, the font of the user interface and the default colours of diagrams (see Preferences).

6. Diagram types

UML Wizard draws a subset of UML 2.x (UML 2.5.1) notation. It does not claim full conformance to the OMG specification and has no XMI import or export. Help → About UML Wizard shows the supported version.

Class diagrams

Sequence diagrams

State machine diagrams

Activity diagrams

Use case diagrams

Component diagrams

Deployment diagrams

An artifact inside an execution environment or node is deployed on it; «deploy» shows the same thing with an arrow.

Every diagram type

Notes (UML comments, attached to elements and connectors with dashed lines), text boxes (free labels, not UML), fonts, fill, border and line colours. The colours and text boxes are not UML notation.

Connections that are refused

Nothing leaves a final node or enters an initial node; only transitions loop back to their own node; system boundaries are not connected; «include» and «extend» connect use cases; generalizations connect two actors or two use cases; realizations end at an interface; «deploy» goes from an artifact to a node, device or execution environment, «manifest» from an artifact to a component; communication paths connect nodes.

Not supported

• Class diagrams: packages, constraints ({…}), association classes, n-ary associations, qualified associations, templates, derived attributes (/), association end names and navigability markers. Two relationships between the same pair of classes are drawn on top of each other.
• Sequence diagrams: combined fragments (alt, opt, loop, par, …), execution specifications (activation bars), destruction, interaction uses, gates, found and lost messages.
• State machine diagrams: composite and orthogonal states, entry/do/exit behaviours, history, fork/join, junction and terminate pseudostates.
• Activity diagrams: object nodes and flows, swimlanes (partitions), flow final, signals, exception handlers.
• Use case diagrams: extension points, multiplicities on associations.
• Component diagrams: ports, required interfaces (sockets), assembly and delegation connectors, packages.
• Deployment diagrams: deployment specifications, instance names (name : Type), multiplicities on communication paths.
• Other diagram types: object, package, composite structure, communication, timing, interaction overview and profile diagrams.

7. Tagged values

A tagged value is a name and a value, such as status = draft, attached to a model element. It is UML's way of recording information the notation has no place for. UML Wizard keeps tagged values on diagrams, classes (of every kind: classes, abstract classes, interfaces and enumerations), attributes and operations. They are saved with the project, but they are not drawn: they are notes about the model, not part of the picture.

Editing them

The class dialog shows the tagged values of one element at a time, below the lists of attributes and operations; its heading says whose they are. In every place they are edited the same way:

• Add Tagged Value adds a row: type the name in the first box and the value in the second.
• The button at the end of a row removes it.
• Rows without a name are dropped when you click OK; Cancel keeps the tagged values as they were.
• Changes made in the class dialog can be undone with Ctrl+Z, like any other change to the diagram.

Tagged values UML Wizard uses

Most tagged values are yours, and UML Wizard only keeps them. A few are set and read by UML Wizard itself:

Leave the openapi.… tagged values as they are unless you know the OpenAPI format: they hold JSON, and removing one loses that part of the description when the diagram is exported to OpenAPI. Changing the diagram itself, e.g. a type or a parameter, is always safe; where the two disagree, the diagram wins.

Your own tagged values

Use them for anything you want to keep with the model, for example:

• on a diagram: status = draft, version = 2.1, reviewed-by = Sam, ticket = SHOP-123;
• on a class: owner = payments team, table = orders, since = 3.0;
• on an attribute: unit = EUR, pii = true, column = order_total;
• on an operation: idempotent = true, deprecated = use submit().

UML Wizard keeps them with the diagram, through saving, copying and pasting classes, undo and redo. They are not drawn, and are not part of exports: PNG images do not show them, PlantUML has no place for them (the export lists how many it left out), code generation does not use them, and OpenAPI export only uses the ones in the table above.

Choose short, lowercase names, and use the same name for the same thing everywhere, e.g. always owner, never Owner in one class and team in another. Do not start your own names with openapi.: OpenAPI export reads every tagged value with that prefix.

8. Exporting an image

1. Select a diagram in the Project Explorer and choose Diagram → Export → PNG Image…
2. Enter the output folder (or Browse…) and the file name; .png is added when missing. Either field warns in red when the file already exists, and OK asks before replacing it.
3. Choose a white or transparent background (shapes filled white and label backgrounds stay white).

The folder and background are offered again for the next export while the app runs. An open diagram is exported as shown, including unsaved changes.

9. Generating code

Select a class diagram in the Project Explorer and choose Diagram → Generate Code…. Pick:

• the language: C#, Java, Kotlin, TypeScript, Ruby or C++ out of the box, more with plug-ins;
• the namespace (package in Java and Kotlin, module in Ruby, the folders of the files in TypeScript; optional, e.g. Shop.Domain or Shop::Domain); the project name is suggested;
• the output folder, created if needed; Generated/<language> next to the project file is suggested.

The dialog lists the files it will write, marks the ones that replace existing files, and shows notes on what the language cannot express; OK asks before replacing files. An open diagram is generated as shown, including unsaved changes. Help → How to Generate Code walks through an example.

• Inheritance and realization become base classes and implemented interfaces. Every language but C++ has one base class: further ones are left out, with a note. An operation that overrides one of a base class is marked as an override where the language needs it. A concrete class gets stubs for the inherited abstract and interface operations it does not list, so the code compiles.
• Associations, aggregations and compositions become fields of the class the relationship leads from: both ends for a plain association, the source for directed associations, aggregations (the whole) and compositions. A field is named after the other class, in the plural for multiplicities above one (*, 0..*, 1..*, 2), which makes it a list. No field is added when an attribute already has that class as its type. In C++ classes are referred to by pointer, and compositions own their parts through std::unique_ptr. The relationship's label becomes the field's documentation comment.
• Notes attached to a class and its stereotype become the class's documentation comment.
• Types such as int, string, bool, decimal, DateTime, Guid, List<T>, Set<T> and Map<K, V> are written the language's way; classes of the diagram are used by name; other types are used as written, with a note. A default value that names a literal of an enumeration (status: OrderStatus = New) is qualified the language's way.
• The notes in the dialog also list what is not generated, such as operations of enumerations in C#, C++ and TypeScript, or overloaded methods in Ruby and TypeScript.

10. Importing code

Import Source Folder (the start screen, or File → Import Source Folder…) creates a new project from existing code, with a class diagram of its types, laid out automatically.

1. Pick the folder. For a C# project, pick the project's folder.
2. The dialog offers the languages the folder has files of, the most common first, and says up front what the import leaves out.
3. Enter the new project's name, author, description and location.

The diagram opens, and a summary lists what was imported and everything that was left out or shown differently. A folder with no source files of an importable language, or no types, is not imported. The code is not built, so nothing needs to be restored or compiled.

Every source file of the chosen language under the folder is read, leaving out hidden folders (.git, .vs, …), build output and dependencies (bin, obj, build, out, target, dist, packages, node_modules, vendor).

Left out, and counted in the summary: files of other languages; method bodies, comments and documentation; base types that are not part of the import (e.g. Exception); initial values longer than 40 characters; and what each language has that a class diagram cannot show, e.g. events, indexers and operators in C#, annotations in Java and Kotlin, decorators and type aliases in TypeScript, destructors, friends and free functions in C++, and methods defined at run time in Ruby. Ruby declares no types, so Ruby classes are linked only by inheritance and mixins, not by associations.

11. OpenAPI

Diagram → Import → OpenAPI… reads an OpenAPI 3.0 or 3.1, or Swagger 2.0, description (.yaml, .yml or .json) and adds a class diagram to the folder of the Project Explorer selection, laid out automatically. Diagram → Export → OpenAPI… writes the selected class diagram as OpenAPI 3.0: the file's extension chooses YAML or JSON, and the dialog asks for the API's title (the diagram name by default) and version.

What UML has no place for is kept in tagged values named openapi.… and written back on export, so importing and exporting an OpenAPI 3.0 description gives it back; when the diagram changes, the diagram wins. The import lists anything it could not keep. Help → How to Import and Export OpenAPI has the details, including how the Method and Path of an operation become an endpoint.

12. PlantUML

Diagram → Import → PlantUML… reads a PlantUML file: each diagram in it, from @startuml to @enduml, is added to the folder of the Project Explorer selection and laid out automatically. Its kind is recognised from its content, as PlantUML does, and its title names it. Diagram → Export → PlantUML… writes the selected diagram, of any type, as PlantUML, with its name as the title. Both list what they could not keep.

Not exported: text boxes, fonts, colours, line styles and tagged values. Not imported: styling, combined fragments of sequence diagrams (their messages are kept), composite states (flattened), history states, swimlanes (their actions are kept) and !include. Help → How to Import and Export PlantUML shows how each kind of diagram maps.

13. AI assistant

UML Wizard can use an AI service to draw a diagram from a description, and to talk about and change your diagrams in a chat. The AI is optional and off until you set it up: nothing is sent anywhere before that, and afterwards only when you use an AI command.

Setting up an AI service

1. Open File → Preferences… and the AI tab.
2. Choose the Service:
   • Anthropic (Claude): needs an API key from Anthropic. The model is claude-sonnet-5-5 unless you name another, e.g. claude-opus-5-5 for large or subtle diagrams.
   • OpenAI-compatible: OpenAI itself (with an API key), or any service with the same API, including models running on your own computer with Ollama (http://localhost:11434/v1) or LM Studio (http://localhost:1234/v1), which need no key. Enter the Endpoint and the Model, e.g. gpt-4o-mini or llama3.1.
3. Enter the API key, if the service needs one. It is kept in your system's credential store (Windows Credential Manager, the macOS Keychain, or the Secret Service on Linux), not in the settings file. Instead, you can set the ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable.
4. Leave Changes on With tool calls, unless the model cannot call tools (some local models cannot; the chat then reports an error from the service). Choose As a whole diagram for those: see Chatting about a diagram.
5. Click Test Connection: UML Wizard sends a short request and says whether the service answered.

Choosing None (AI off) turns the AI commands off again. On Linux, keeping the key needs the secret-tool command (package libsecret-tools); without it, use the environment variable.

Creating a diagram with AI

1. In the Project Explorer, select the folder the diagram should go into (or a diagram in it).
2. Choose Diagram → Create with AI…
3. Describe the diagram in your own words, and choose its Type, or leave Let the AI choose.
4. Click OK. A window says what is happening; Cancel stops it.

The new diagram is laid out, added to the folder and opened. Its description says it was created with AI, and from what. If the AI wrote something UML Wizard does not support, it is listed, and the rest of the diagram is kept. Create with AI does not change your existing diagrams: it only adds new ones, which you can edit, undo and delete like any other. To change a diagram with AI, use the chat.

How it works: the AI writes the diagram as PlantUML, which UML Wizard reads with its PlantUML import, checks and lays out. If the answer cannot be read as a diagram, UML Wizard asks the AI once more.

Chatting about a diagram

View → AI Chat (Ctrl+Alt+I) shows the AI chat on the right of the window; it is hidden when UML Wizard starts. It is about the diagram of the active tab: each tab has its own conversation, which is not saved with the project.

• Type a question or a request in the box at the bottom and click Send, or press Ctrl+Enter (⌘+Enter on macOS). Stop ends a request that takes too long; nothing from it is kept.
• Ask about the diagram: "What does this diagram show?", "Review this design", "Which classes have no relationships?". The AI sees the whole diagram.
• Ask for changes, in any kind of diagram:
  • Class diagrams: "Add a Payment class that Order is composed of, with an amount and a status", "Make Shape abstract", "Rename Customer to Buyer", "Remove the dependency from Cart to Logger". The AI adds, renames and deletes classes, attributes, operations, enumeration literals and relationships.
  • State machine and activity diagrams: "Add a Cancelled state reachable from Created and Paid", "After Check stock, add a decision: ship when in stock, else back-order". States, actions, initial and final nodes, decisions, choices and fork/join bars, with their transitions and flows, triggers, guards and effects.
  • Use case diagrams: actors, use cases inside the system, associations, «include», «extend» and generalizations.
  • Component and deployment diagrams: "Deploy shop-web.dll on a Kestrel environment on the Web Server", "Add a database node connected over TCP". Components, interfaces, nodes, devices, execution environments and artifacts, and what is deployed on what.
  • Sequence diagrams: "After checkout, the shop calls payments.pay(total)", "Remove the second reply". Lifelines and messages; a message added in the middle moves the later ones down.
  The AI also adds notes. It follows the same rules as the editor: e.g. nothing leads into an initial node, and only an artifact is deployed with «deploy».

The answer appears while the AI writes it, with its formatting: bold, lists and code.

Changes are not made straight away. Under the conversation, Proposed changes lists them, e.g. + class Payment or + Order → Payment (composition):

• Apply makes them, as one step: a single Undo takes them all back.
• Discard drops them; the diagram stays as it was.
• Asking for more before deciding adds to the same proposal.

What the AI adds is placed next to what it is connected to, in free space, without moving anything: a class next to a related class, a state next to the state it follows, an artifact inside the node it is deployed on (which grows to hold it). In an empty diagram, everything the AI adds is arranged. Use Format → Arrange Diagram afterwards if you want the whole diagram tidied.

The first time you send a message in a project, the chat asks whether the project's diagrams may be sent to the service. Allow for This Project sends the message, and UML Wizard remembers the answer for that project; Cancel keeps the message in the box and sends nothing.

Models without tool calling. The AI normally changes a diagram step by step ("add a class", "add a transition"), which needs a model that can call tools. For a model that cannot, set Preferences → AI → Changes to As a whole diagram: the AI then answers with the whole revised diagram in PlantUML. UML Wizard matches it with your diagram by name, so what keeps its name keeps its place, look and tagged values; what is new is placed; what the AI left out is removed. The proposed changes show all of it before you apply it. This works best with class, state machine, use case, component and deployment diagrams; activity diagrams may be rebuilt rather than changed.

The chat sends your messages and the diagram to the AI service. The panel says which service; see Privacy above.

Describing a diagram well

• Name the things that matter: "classes Order, OrderLine, Customer and Product; an order has one or more lines; each line refers to a product".
• Say how they relate or in what order things happen: "the customer pays, then the shop reserves the stock and ships the order; payment can be retried twice".
• Choose the diagram type when you know it; the AI's choice is a guess.
• Keep it focused: one diagram per idea; 5 to 15 elements read best.
• Check the result: AI can misunderstand or invent details. Treat the diagram as a draft.

Privacy

When you use an AI command, what you type is sent to the service you chose, and the AI chat also sends the diagram it is about; and is subject to its terms. Choose a local model (Ollama, LM Studio) to keep everything on your computer. Your API key is only sent to that service.

14. Adding languages

Every code generation and code import language is a plug-in: a DLL loaded at start-up from two plugins folders. The built-in ones are in the application's folder. To add a language, put its DLL in your own plug-ins folder and restart UML Wizard:

• Windows: %APPDATA%\UmlWizard\plugins
• macOS and Linux: ~/.config/UmlWizard/plugins

A plug-in goes there as Name.dll, or as Name/Name.dll with its dependencies. It then appears in the Language box of Generate Code or the language choice of Import Source Folder. To remove it, delete its DLL (or its folder). When both folders have a DLL with the same name, the application's wins.

Help → About UML Wizard → Languages lists every installed language plug-in with its version and provider, and the plug-ins that could not be loaded, with the reason.

15. Menus

Rename, Move To, Delete, Export, Generate Code and Properties in the Diagram menu act on the diagram selected in the Project Explorer.

16. Keyboard shortcuts

Shortcuts use Ctrl on Windows and Linux and ⌘ on macOS.

17. Preferences

The Preferences window sets how UML Wizard works and looks for you: where new projects go, the language and font of the application, and the colours diagrams are drawn in. Preferences belong to you, not to a project: they apply to every project you open, and a project you share keeps its own look for others.

Opening the window

• Choose File → Preferences…, or press Ctrl+,.
• On macOS, also UML Wizard → Preferences… in the menu bar, or ⌘,.

The window has four tabs: General, Appearance, Diagram and AI. Each setting is a label on the left with its control on the right.

There is no OK or Cancel: every change applies at once and is saved straight away. Change something back the same way you changed it, then click Close (or press Esc) when you are done. Drag the window's edges to make it larger.

General

Appearance

These settings change the application itself, not your diagrams.

The Preview below the settings shows a small window, with a title, text, a text box, a check box and a button, in the font and size you choose, so you can judge them before closing the window. Every window of the application changes as well.

The text of diagrams has a font of its own, which is part of the diagram: set it with Format → Diagram Font… (all the elements of a diagram) or Format → Font… (one element).

Diagram

This tab sets the colours shapes are drawn in, for each type of diagram. Pick the diagram type in the list on the left; its settings appear on the right:

• Fill: a colour for each kind of shape the diagram type has.
• Border: the colour of the outline of every shape of that diagram type.
• Thickness: the width of that outline, from 0.5 to 8. Leave it empty for the default (1.2).

Each colour has a swatch and a box with the colour as #RRGGBB:

• Click the swatch to choose the colour in the colour picker.
• Or type the colour in the box, e.g. #FDE7E7; it applies as soon as it is a complete colour.
• To go back to the theme's colour, empty the box or click the restore button next to it. While a colour is not set, the swatch and the greyed text in the box show the theme's colour.
• Reset to Defaults puts every fill, the border and the thickness of the diagram type back to the theme's.

Open diagrams of that type change as you go, so you can watch the result while you choose.

AI

The AI service the AI commands use: Service, Endpoint, Model, how the chat makes Changes (with tool calls, or as a whole diagram for models without tool calling) and API key, with Test Connection. The API key is kept in your system's credential store when you close the window, not in the settings. See AI assistant for how to set up each service.

Examples

Create new projects in a folder of your own

1. Open File → Preferences…; the General tab is shown.
2. Click the folder button at the end of Projects folder and choose the folder.
3. Click Close. Create a New Project now offers that folder.

Make interfaces stand out in class diagrams

1. Open the Diagram tab and pick Class diagram.
2. Click the swatch next to Interface, choose a colour in the colour picker and click OK.
3. Set Thickness to 2 for bolder outlines, and click Close. Every interface of every class diagram, open or not, is drawn in the new colour.

Make the application easier to read

1. Open the Appearance tab.
2. Set Font size to 16, and pick another Font if you like; check the Preview.
3. Click Close.

Good to know

• A shape that has colours of its own (Format → Shape…) keeps them. In that dialog, Default means the colour from Preferences, or the theme's when Preferences set none.
• The colours you choose are the same in light and dark mode. Text on a fill turns dark or light, whichever reads better.
• Exported images (Diagram → Export → PNG Image…) use your colours too.
• Text boxes have no border, so the border settings do not apply to them.
• The colour picker's custom colours are kept with your preferences.

18. Where settings are kept

The recent projects list (recent-projects.json), your preferences (settings.json) and your plug-ins (plugins) are kept in:

• Windows: %APPDATA%\UmlWizard
• macOS and Linux: ~/.config/UmlWizard

Projects are kept wherever you create them: a project is a single .umlwiz file with all of its diagrams.