GitHubGitHub Stars
v0.56.x1 release
v0.56.02026-11-05

SysML 2 as a complete diagram family, notes everywhere, workspace PDF export

SysML 2 now covers a complete family of nine diagram types, and every notation gains notes. Layout and label placement have a new foundation with 50 % more space between components, the LaTeX/TikZ output catches up with the SVG output, and kUML Desktop adds workspace PDF export and an MCP workspace mode. One breaking change affects the expression parser.

Added

  • SysML 2 diagram family: state machines (composite and orthogonal states, timers, history, junctions), activity diagrams (signals, time events, interruptible regions, swimlanes), requirement and use-case diagrams, block definition and internal block diagrams with ports, flows and allocation, parametric diagrams, sequence-diagram extensions, package diagrams with views and viewpoints, and analysis cases and calculations.
  • Notes on every diagram type: note kinds with symbols, formatted note text (bold, italic, code, lists, links), placement without overlap and anchors that attach to the drawn geometry, for UML, SysML 2, C4, BPMN, ERM and Service Blueprint. The C4 and Service Blueprint DSL printers write notes too, and there is a new Service Blueprint DSL printer.
  • LaTeX/TikZ output: notes (UML, SysML 2, C4, BPMN, Service Blueprint), UML edge labels, aggregation and composition diamonds, navigability, include/extend notation, labels on a backdrop, and BPMN message flows that build with pdflatex again.
  • kUML Desktop: icons in the menu and on dialog buttons, an About dialog, a preview toolbar (actual size, centre, export to SVG, PNG and PDF), adjustable column widths and scrollable documents in the Knowledge Workspace, a simulator inspector, and a hint in the MCP dialog that the server runs only while the app is open.
  • Workspace PDF export from the CLI, the Desktop and MCP, plus a workspace mode for the Desktop MCP server.
  • Multi-script model composition: transform and generate over several .kuml.kts files.

Changed

  • Label and layout foundation: deterministic layout, collision-free label placement for UML, SysML 2, C4, ERM and Service Blueprint, and edge ends that dock on port and pin borders.
  • More space between components: every ELK-laid-out diagram spaces components 50 % further apart (LAYOUT_SPACING_SCALE 1.5), so longer labels fit. Box and font sizes are unchanged.
  • ERM labels: name labels are planned along the whole length of a line, so a self-loop label moves above the loop when there is no free spot beside it.
  • LaTeX/TikZ end labels at diamonds and open heads keep clear of the symbol.

Breaking

  • In the expression parser, the word operators and, or and not are recognised in lowercase only and never directly after a .. Uppercase AND, OR and NOT are no longer operators. Identifiers that are named like operators need backticks.

Removed

  • The outdated guides docs/getting-started.adoc and docs/diagram-types.adoc; the handbook replaces them.

Known limits

  • BPMN collaboration notes in LaTeX have no association line.
  • ERM has no LaTeX renderer.
  • SysML 2 package diagrams have no LaTeX renderer.
  • LaTeX end labels still have no label planner: very short end segments can still overlap a diamond or chevron.
v0.55.x4 releases
v0.55.32026-10-21

kUML Desktop: dialogs that show up, ⌘ shortcuts on macOS, a tidier document header

kUML Desktop opens its workspace dialogs as real windows, uses the ⌘ key for menu shortcuts on macOS, shows scripts you save in the Engineering workspace tree, and gets a cleaner document header with Read/Edit tabs.

Fixed

File → New Workspace… showed no dialog

The “New Workspace…”, “Trust this workspace?” and “Open as…” dialogs were drawn inside the main window and disappeared behind (or were cut off by) the editor and the diagram preview. They are now real dialog windows, like the About dialog.

macOS: menu shortcuts use ⌘

Save, Undo, Redo, Find, the view-mode switches and Simulate were bound to Ctrl, so a Mac needed ⌃S instead of ⌘S. All menu shortcuts now follow the platform convention: ⌘ on macOS, Ctrl on Windows and Linux.

New scripts did not appear in the Engineering workspace tree

A script created via Save or Save As stayed invisible in the navigation. The tree now refreshes after saving and when you switch files.

Changed

  • Document header: type and title sit above, and Read/Edit are now tabs directly above the content they switch. Type and title share one height and line up. The type: dropdown shows a proper arrow.
v0.55.22026-10-17

Web editor starts again, Kotlin reverse honours --include/--exclude

The `kuml serve` web editor loads without any CDN script and starts reliably, `kuml reverse --lang kotlin` finally applies `--include`/`--exclude`, and the test suite runs cleanly on Windows.

Fixed

kuml serve: the web editor did not start

The web editor loaded CodeMirror from esm.sh and combined a legacy @codemirror/basic-setup with CodeMirror 6 packages. That pulled in two instances of @codemirror/state, the browser reported “Unrecognized extension value in extension set” and the editor was never created. The frontend is now built from one locked npm dependency graph and bundled with Vite, so the page no longer loads any script from a third-party CDN. A Playwright regression test runs the packaged distribution in a container. Contributed by @WhereJuly (#5), which fixes #4.

Kotlin reverse engine ignored --include/--exclude

kuml reverse --lang kotlin never applied the globs, so test and spec files could not be left out of the model. Globs are now matched against the file name or the path relative to the source root (*Test.kt, **/test/**), excludes win over includes, excluded files are not parsed, and an invalid glob fails with the new diagnostic REV-CORE-003. The Java engine is unchanged. Fixes #6.

Changed

  • Building kUML from source now needs Node.js (^20.19 or >=22.12) with npm, because kuml-web bundles its frontend with Vite. Release binaries, Homebrew, Chocolatey, SDKMAN and the Maven artifacts are not affected.
  • Tests are portable to Windows (path separators, CRLF, symlink-restricted accounts, Windows file locking). Test code only, no behaviour change.
  • kuml-web frontend dependencies updated (@codemirror/view 6.43.14, Vite 8.3.4, Playwright 1.64.1).
v0.55.12026-10-12

kUML Desktop: resizable split, mouse navigation and the real logo

The divider between editor and preview can be dragged, the diagram preview pans and zooms with the mouse, Help ▸ About shows the version and the app icon is the official kUML logo. Also: the JetBrains plugin and the macOS packages missing from v0.55.0 are published, and several stability fixes.

Added

Resizable editor/preview split

In split view the divider between source editor and diagram preview can be dragged (at least 15 % and 200 dp per pane), nudged with the arrow keys when focused (Shift for larger steps, Home/End for the limits) and reset to 50/50 with a double-click or Enter. The position is saved when you release the mouse.

Mouse navigation in the diagram preview

Drag with the left button to pan, scroll the wheel or trackpad to pan (Shift: horizontally), hold Ctrl or Cmd while scrolling to zoom around the pointer, double-click to fit the diagram to the window. Applies to the editor preview, the Knowledge Workspace viewer and the AI patch preview.

Version in Help ▸ About kUML…

The About dialog shows the app version, and the desktop MCP server reports it instead of dev.

Official logo as application icon

The icon is now the kUML logo from kuml.dev ({k} and the wordmark) on a proper macOS tile, with the {k} mark alone at small sizes. kuml-desktop/scripts/generate-app-icon.py regenerates it.

Fixed

Missing artifacts of v0.55.0

v0.55.0 shipped without the JetBrains plugin build and without the macOS installer and runtimes: the plugin failed the Marketplace verifier (a Kotlin 2.4 standard-library call missing on IntelliJ 2024.3 and 2025.1, now avoided) and Apple’s notarization service rejected the uploads until an account agreement was renewed. v0.55.1 publishes all of them.

Stability

AiProviderSettingsState.awaitPendingWrites() could throw a NoSuchElementException when a write finished at the wrong moment (a race in toList() on a concurrent queue); this was also the sporadic CI failure of AiProviderSettingsStateTest. Two other timing-sensitive desktop tests are now deterministic.

Tooltips

Toolbar tooltips no longer cover their own button. They appear beside the button inside the toolbar, because Compose popups are not drawn over the editor and the preview.

v0.55.02026-10-10

kUML Desktop gets an MCP server: let your AI agent work in the running app

kUML Desktop can now host an optional local MCP server. An agent such as Claude Code reads and replaces the script that is open in the app, validates it and renders it, while you watch the live preview. Also fixes a blank preview in the installed desktop app and refreshes dependencies.

Added

kUML Desktop: optional local MCP server

Enable it under Tools ▸ MCP server…. It is off by default, listens on 127.0.0.1 only and is protected by a bearer token. The dialog copies a ready-made claude mcp add command.

  • Seven live tools: kuml_desktop_get_script, kuml_desktop_set_script, kuml_desktop_render, kuml_desktop_validate, kuml_desktop_get_last_error, kuml_desktop_get_theme, kuml_desktop_set_theme, plus the four authoring tools (kuml.describe, kuml.examples, kuml.generate, kuml.list_elements).
  • set_script uses optimistic concurrency: it needs the revision the agent last read, so your own edits are never overwritten. A replacement is one Undo step and never saves a file; a notice with an Undo button appears in the app.
  • Security: 256-bit token in its own owner-only file, constant-time comparison, strict Host and Origin checks, 1 MiB request limit, timeouts. Anyone holding the token can run Kotlin code in the app, so keep the server off when you do not need it.

kuml-mcp public API

The protocol logic (McpRequestHandler, McpToolRegistry, McpTool, KumlAuthoringTools) is now public and transport-independent. The stdio server’s output is unchanged.

Fixed

Blank preview in the installed desktop app

The Java runtime bundled with the DMG, MSI, DEB and RPM was missing the jdk.unsupported module, so every render failed with java.lang.ExceptionInInitializerError, including newly created OKF workspaces. The runtime modules are now pinned explicitly and covered by a regression test. The CLI and running the app from source were not affected.

Changed

Dependencies refreshed: Gradle 9.8.1, Koog 1.3.0, Ktor 3.6.0, Compose Multiplatform 1.12.1, Kuiver 0.4.2, Coil 3.6.3, Kotest 6.2.5, JUnit 6.1.3, Logback 1.6.5 and more. Kotlin stays on 2.4.10 and JSqlParser on 5.3 because newer versions break the reverse-engineering modules.

v0.54.x1 release
v0.54.02026-09-12

Guard-evaluation security fix, BPMN process simulation, and UML association classes

A security fix closes fail-open gaps in guard evaluation on the state-machine path — a guard comparing against data that was never provided could previously fire when it should have blocked. Also new: `kuml simulate` runs BPMN process diagrams end to end, kUML Desktop gained live state-machine simulation and an editable OKF Workspace document view, UML gained proper association classes, and the JetBrains plugin's long-blocked Marketplace publish is unblocked.

Security

Guard evaluation had fail-open gaps on both the state-machine and Activity/BPMN paths

A guard comparing against a variable the event stream never actually provided (vars.missing <> 1, event.x != 1, or the equivalent dot-navigation / function-call forms) could evaluate to a trusted true instead of failing safely — meaning a transition could fire, or a BPMN/Activity branch could take the “allowed” path, based on data that was never supplied. This affected both guard evaluators: the newer Activity/BPMN evaluator and the older state-machine evaluator (OclGuardEvaluator), including a related bug where negated guards ("!allow") were silently dead code on the Activity/BPMN path and never took the negated branch at all, regardless of the underlying value.

Both evaluators now share a single fail-closed check: a true result is discarded if it comes from a variable the model never received, downgrading it to a reported guard failure instead of a silent, trusted true. false results remain trusted (the safe direction), and &&/||/and/ or/implies keep evaluating short-circuit, so a legitimately true isVip || spendOver1000 still fires even if spendOver1000 was never set. Guard-evaluation crashes (a malformed OCL expression, a stack overflow from a very long chain, an interrupted sandbox) are now reported as a failure instead of propagating as an exception.

Breaking change for one specific idiom: vars.x = null / vars.x == null used as “is X not set” no longer fires when x is missing — it now reports a guard failure instead of a trusted true. Models relying on this pattern should switch to vars.x.oclIsUndefined(), which correctly treats “never set” and “explicitly set to null” as equivalent.

A related audit of the new TokenFlowEngine (BPMN simulation, see below) closed five further gaps: an unsandboxed replay path, a BPMN sub-process/loop/boundary-event combination that silently degraded to a false “success”, an INCLUSIVE gateway split that could drop a token without warning, unvalidated CLI numeric options that could overflow a timeout calculation, and guard timeouts/exceptions that were indistinguishable from a legitimately false guard.

Added

kuml simulate for BPMN process diagrams — new TokenFlowEngine

A new model-agnostic TokenFlowEngine runs BPMN 2.0 process diagrams, UML Activity diagrams, and SysML 2 Action diagrams against the same Petri-net-style token-flow semantics. kuml simulate <script.kuml.kts> <events.json> auto-detects a BPMN process diagram and routes it through the new engine; --process <id> selects a process when a model declares several, --max-tokens and --time-budget-ms bound token explosion and runtime in cyclic models. Supports EXCLUSIVE/ PARALLEL/INCLUSIVE gateways (converging, diverging, mixed), terminate/flow-final events, and BPMN default flows. A collapsed sub-process (no own content) runs as a single opaque node; an expanded sub-process with real content, loop characteristics, or boundary events is explicitly unsupported and reported as an error rather than silently skipped.

Live state-machine simulation in kUML Desktop — new Tools ▸ Simulate (Ctrl+R) for UML state machines and SysML 2 state-machine diagrams. Starts a sandboxed live session in the preview panel: step / auto-advance / reset, a list of events valid from the current state, and a trace column with scrubbing. Active states highlight via a live DOM patch on the existing SVG (zoom/pan preserved) instead of a full re-render on every step.

OKF Knowledge Workspace documents are now editable in kUML Desktop — previously a read-only Markdown viewer, now with a read/edit toggle in the same editor used for .kuml.kts scripts, including undo/redo and find. Frontmatter (type:, title:) gets its own header controls that splice surgically into the existing buffer, leaving comments, unknown keys, and their order byte-identical.

UML gains association classes (ADR-0017) — UmlAssociationClass models the standard UML concept of an element that is simultaneously a classifier (attributes, operations, inheritance) and a relationship (connects two classifiers), as a single element with one id — not two coupled objects that could drift apart. Full DSL builder, both DSL-printer dialects, layout-bridge placement (with a dashed tether line to the parent association), and SVG rendering are supported. Codegen and the Compose-based Kuiver renderer don’t support association classes yet.

SysML 2 and C4 DSL round-trip completeness gaps closed (ADR-0017) — several previously documented DSL-builder gaps below what the underlying metamodels actually support are fixed: isAbstract/specialization on more SysML 2 definition types, 8 additional Sysml2Usage DSL constructors, and five C4 gaps (model description, container-instance id, a Code-level DSL entry point, layout hints on deployment nodes, and include(...) on container/component diagrams). ScriptSerializer’s C4 and SysML 2 printers are also now implemented, closing two long-standing stub gaps.

Fixed

JetBrains plugin: Marketplace publish unblocked (fixed an internal-API verifier failure)

Every Marketplace submission since 0.51.0 was silently rejected: the Markdown-preview integration used an IntelliJ Platform extension point marked @ApiStatus.Internal. Replaced with the sanctioned MarkdownBrowserPreviewExtension extension point — same rendered result, no visible behavior change. CI now runs the Plugin Verifier before every publish, so a regression like this fails the build instead of silently reaching the Marketplace queue. Also fixed: a layout jump on every keystroke while editing a kuml fence in a Markdown document.

  • A script-sandbox worker-pool shutdown race that could leak a child JVM under load.
  • UML association navigable is now respected by both renderers.
  • kUML Desktop: saving an OKF Workspace document on macOS could corrupt that document’s identity in the tree (a symlink-resolution mismatch between /var and /private/var).

Full changelog: github.com/kuml-dev/kUML/releases/tag/v0.54.0

v0.53.x1 release
v0.53.02026-08-25

Security fix for the desktop app's macOS Keychain, plus a new AI Providers dialog

A macOS Keychain bug that could route one AI provider's API key to a different provider's endpoint is fixed — re-enter your keys if you've used the AI Providers dialog on macOS before. Also new: a proper dialog for configuring AI providers, models and API keys, real tool-calling in the AI panel, a real app icon and view-mode toggle, and logging that finally works.

Security

macOS Keychain credential misrouting — cross-provider API key leakage (fixed)

kuml-desktop’s API-key vault stored every cloud AI provider’s key under the same macOS Keychain item, distinguished only by a cosmetic label rather than a real search predicate — security find-generic-password matches on (account, service) only, not on label. Saving a second provider’s key silently overwrote the first, and reading any provider’s key actually returned whichever one had been written last. In practice, an API key entered for one provider could be dispatched to a completely different provider’s endpoint.

Fixed by giving each provider its own independent (account, service) identity in the Keychain, verified against the real macOS Keychain — not just mocked — with a shared cross-backend contract test suite. If you’ve used the AI Providers dialog on macOS before this release, please re-enter your API keys — the dialog also detects and flags a leftover shared-service item automatically.

Also fixed in the same pass: security add-generic-password requires its value on stdin twice (password + confirmation) when stdin isn’t a real terminal — the vault previously wrote it once, which could silently store an empty secret.

Added

A new AI Providers dialog

Enabling a cloud provider, changing its default model, or storing an API key used to mean hand-editing a JSON settings file. A new dialog — reachable from the AI menu, or a new “Providers…” button in the panel header — now covers all of it: enable/disable per provider, pick a default provider and model, manage each provider’s API key.

A privacy-mode switch frames the whole dialog. While it’s on, only local providers (Ollama) are selectable. Turning it off requires an explicit, specific confirmation naming the actual consequence — not a generic “Are you sure?” — before any prompt or diagram content can leave your machine.

The dialog also closes a real crash source: enabling a cloud provider without ever storing an API key for it used to bring down the entire AI executor on the next message, not just that provider, because the executor builds every enabled provider’s client up front. The dialog now enforces the same invariants the executor requires before it lets you save.

Real tool-calling in the desktop AI panel

The AI panel’s “direct” (non-orchestrated) agent path used to decode a patch from the LLM’s text output but never actually execute any tool against the open diagram — and the editing context it grounded the LLM with was built once per session from an always-empty model instead of the diagram actually open in the editor, so every turn after the first operated on stale or empty context. Both are fixed: the panel now does real tool-calling against the same tool registry the orchestrated agent path uses, and re-seeds its editing context from the current script before every turn.

Real app icon, a Source/Split/Diagram view toggle, and a live Ollama model list

  • kuml-desktop finally ships its own app icon (derived from the {k} brand mark) instead of falling back to a generic Java icon.
  • A new view-mode toggle (View menu, or Cmd/Ctrl-1/2/3) switches between seeing only the script source, a split source+diagram view, or only the rendered diagram — persisted across restarts.
  • The Ollama model dropdown now queries Ollama’s own /api/tags endpoint for the models actually installed locally, instead of showing a static suggestion list.
  • The zoom toolbar uses real icons instead of raw text glyphs.

Desktop UX polish

  • An inline incremental find bar (Ctrl+F / Cmd+F) in the editor.
  • An opt-in “Powered by kUML” watermark for the live preview and SVG/PNG export — off by default, matching the CLI.
  • Compact icon buttons for the zoom, view-mode, and find toolbars.
  • Tooltips that anchor to their button instead of following the cursor.
  • Radio-button indicators for the active theme and language in the View menu.
  • Enter sends, Shift+Enter inserts a newline, in the AI panel’s chat input (during active IME/CJK composition, Enter still confirms the composition rather than sending).

Fixed

  • Logging actually works now. kUML’s code has always logged through the SLF4J facade, but no module ever shipped an SLF4J provider — every run silently discarded all log output, including the warning that API keys are being stored in plaintext when no OS keystore is available. kuml-desktop, kuml-cli, and kuml-mcp now ship logback-classic. All log output goes to stderr; kuml-desktop also writes a rolling log file (…/kUML/logs/kuml-desktop.log, 5 MB × 7 days, 50 MB cap). A new KUML_LOG_LEVEL environment variable controls kUML’s own verbosity (third-party HTTP/AI loggers stay pinned to WARN regardless, so this can never accidentally turn on request/response body logging). kuml-web has the same root cause but is deferred to a follow-up release.
  • The AI panel crashed with “Key was already used” during multi-round tool calls — Ollama’s tool-call ID could collide across rounds; it’s now always a locally-generated ID.
  • The AI panel crashed on every message sent (kotlinx-coroutines-swing, required for Compose’s Dispatchers.Main, was missing from the runtime classpath).
  • The AI panel’s token-usage counter was permanently stuck at 0/0/$0.00 — it never read the real per-turn token counts every provider already exposes.
  • Theme changes had no visible effect until the next keystroke; two nonexistent theme names were listed in the View menu; Blueprint/Journey-Map diagrams ignored the active theme; Undo/Redo could act on a disposed editor after switching view modes.

Full changelog: github.com/kuml-dev/kUML/releases/tag/v0.53.0

v0.52.x1 release
v0.52.02026-08-20

New: Gonka joins the AI assistant as a fifth built-in LLM provider

kUML's AI assistant now supports Gonka, a decentralized, blockchain-based AI-compute network with an OpenAI-compatible API, alongside OpenAI, Anthropic, Google, and Ollama — via koog-gonka, a Koog LLMClient implementation for Gonka now published on Maven Central.

Added

kuml-ai: Gonka as a new built-in LLM provider

The kUML AI assistant (kuml-desktop’s AI panel, and kuml ai on the CLI) now supports Gonka, a decentralized, blockchain-based AI-compute network with an OpenAI-compatible API, as a fifth built-in provider alongside OpenAI, Anthropic, Google, and Ollama — via koog-gonka, a Koog LLMClient implementation for Gonka now published on Maven Central.

Gonka is wired the same way the other cloud providers are: it requires an API key (Gonka’s Broker endpoint), is treated as a cloud provider under kUML’s privacy mode (blocked by default under privacy mode, exactly like OpenAI/Anthropic/Google — Gonka dispatches prompts to decentralized, network-selected compute hosts, not your own machine), and its model catalog stays dynamic rather than a static table, matching how Ollama’s locally-pulled models are handled, since there’s no fixed, verifiable list of models the network hosts at any given moment.

Only Gonka’s API-key (Broker) authentication is supported. Gonka’s own wallet-based signing protocol isn’t production-ready upstream yet, so kUML doesn’t expose it as an option.

v0.51.x2 releases
v0.51.12026-08-18

Internal fix: JetBrains plugin no longer flags a deprecated-API verifier finding

No user-visible behavior change. The diagram export dialog's compile-time IntelliJ Platform target moved to 2025.1.7.2, and the descriptor it builds is now resolved reflectively so the export dialog keeps working identically on every IntelliJ version the plugin supports.

Fixed

JetBrains plugin: eliminated a Marketplace-verifier “deprecated API” finding on the diagram export dialog

No user-visible behavior change — this is a build/verification-hygiene fix. The plugin’s export dialog built its file-save descriptor using an API that IntelliJ 2025.1+ marks deprecated in favor of a newer overload introduced in that generation. The plugin’s compile-time IntelliJ Platform target moves from 2024.3 to 2025.1.7.2, and the descriptor is now built reflectively, preferring the new API when the running IDE has it and falling back to the previous one otherwise — the fallback path is functionally identical to what shipped before, so behavior on any supported IDE version is unchanged.

The plugin’s minimum supported IDE version stays IntelliJ 2024.3+.

v0.51.02026-08-18

JetBrains: kUML diagram preview in Markdown & AsciiDoc; kuml validate checks named-argument style

The JetBrains plugin now renders kUML diagrams inline while you write docs: `kuml` fenced code blocks in the Markdown preview and `[source,kuml]` / `kuml::` blocks in the AsciiDoc preview both turn into live SVG, with export/copy gutter actions and a shared render cache. Separately, `kuml validate` and the MCP `kuml.validate` tool now check a submitted script's own source for the project's long-standing named-arguments convention, not just its evaluated model — on by default.

Added

JetBrains plugin: kUML diagram preview in Markdown and AsciiDoc documents

kuml fenced code blocks (```kuml) in the Markdown preview and [source,kuml] listing blocks / kuml::path.kuml.kts[] block macros in the AsciiDoc preview now render as inline SVG diagrams, directly in IntelliJ’s built-in preview panels — no separate kuml render step needed while writing docs. Both support theme/name/width attributes, gutter actions (export SVG/PNG/TeX, copy SVG, copy source), Kotlin syntax highlighting inside the block body, and a shared SHA-256/ LRU-50 render cache so the same script+theme combination only ever renders once regardless of which preview surface asked for it.

Markdown integrates via IntelliJ’s CodeFenceGeneratingProvider extension point. AsciiDoc has no equivalent hook — the official AsciiDoc plugin exposes only an HTML-panel-provider EP — so integration instead wraps the stock JCEF preview panel and rewrites the HTML Asciidoctor produces, matching parsed [source,kuml]/kuml:: blocks against the rendered markup so it works regardless of which (if any) source-highlighter is configured. Both the Markdown and AsciiDoc integrations are optional plugin dependencies — kUML still loads and its Kotlin-script preview keeps working normally on IDEs that have neither the Markdown nor the AsciiDoc plugin installed.

kuml:: macro paths are resolved and containment-checked against the .adoc file’s directory (or the project root) before any file is read, rejecting .. escapes, absolute paths outside the project, and http(s):/file:/ftp: targets — including symlink-escape attempts.

kuml validate / kuml.validate: new default-on named-arguments style check

Both the CLI’s validate subcommand and the MCP kuml.validate tool previously only validated a submitted script’s evaluated model (OCL constraints, structural checks, ERM constraints) — never the script’s own source style. This project has long required named arguments for every call to a kUML-owned function/constructor with more than one parameter, specifically because it makes LLM-authored kUML scripts more reliable — but a script submitted through validate got no such check at all, even though it calls the exact same DSL functions.

validate now runs that same check against the submitted script’s actual source text and reports every positional-argument call to a dev.kuml.* function/constructor as an error — valid=false and CLI exit code 5, same as an OCL violation, on by default. The exemptions match the equivalent build-time rule: single-parameter calls, vararg parameters, operator/infix functions, and a block-DSL’s trailing lambda argument are never flagged.

v0.50.x1 release
v0.50.02026-08-12

Fix: MCP renders now use brand colours by default; overflowing text fixed across the renderer

kuml.render (MCP) was still hardcoded to the black-and-white Plain theme while every other surface had switched to the kuml brand theme back in v0.20.5 — now fixed, with an optional theme argument to opt back into Plain. Separately, a whole class of text-overflow bugs across the renderer (edge labels, SysML 2 boxes, BPMN task labels) is fixed by making layout content-aware everywhere it wasn't.

Fixed

kuml.render (MCP): hardcoded PlainTheme(), ignoring the kuml brand-theme default used everywhere else

v0.20.5 made kuml (navy/gold/off-white brand colours) the default theme across the CLI, Web/Server, Gradle plugin, and Desktop — but kuml-mcp’s render tool was never updated and kept instantiating the black-and-white PlainTheme directly, with no theme parameter at all. Every diagram rendered through an MCP client (Claude Desktop, Cursor, etc.) came back monochrome while every other surface had already switched to brand colours.

kuml.render now accepts an optional theme argument (same layering as the CLI: explicit argument, else the built-in default "kuml") and defaults to the brand theme when omitted. An unknown theme name returns a structured error listing the registered themes instead of a generic failure. Pass "theme": "plain" to restore the previous black-and-white output exactly.

This is a visible output change for existing MCP clients: renders that previously came back black-and-white now come back in brand colours by default.

Text overflow across the renderer: edge labels and several node types only sized boxes by connected-edge count, never by their own content

Root-caused into a whole bug class — several node/edge renderers draw text with no width clamp while the matching layout sizer computes box size independently; wherever the two drift, text overflows. Fixed the specific report (a SysML 2 state machine with overflowing action text) plus every other instance the same pattern turned up in a full audit:

  • Long edge/transition labels now word-wrap onto multiple lines instead of drawing one unbounded-width line — this also fixes classic UML state-machine transitions, which reuse the same renderer.
  • Content-aware box sizing, previously opt-in only for kuml-cli, is now the default across every pipeline (Web, Desktop, Gradle plugin, MCP, AI tools, docs). Highest-impact fix: the MCP server and AI-tooling surfaces are the ones most likely to see long, LLM-generated class and attribute names.
  • SysML 2 activity/use-case/sequence/parametric boxes are now content-aware; internal block boxes gained the same edge-fan sizing buffer state-machine and UML boxes already had.
  • BPMN task labels get a clamp when they’d exceed the box’s width cap; sequence-flow condition labels moved to a halo-label style with an arc-length-aware midpoint instead of one that could land off-center on multi-waypoint routes.
v0.49.x1 release
v0.49.02026-08-07

Fix: Exposed defaults and enum CHECK constraints are now actually generated

Once v0.48.0's foreign-key fix let a live database catch further problems, two more gaps in ErmExposedEmitter surfaced: attribute defaults and enum CHECK constraints were rendered as comments, never actual code. Both are fixed — with one narrower case, involving a database-side limitation this Exposed version has, intentionally left as a comment on both generator sides.

Fixed

kuml-codegen-m2m-exposed: attribute defaults and enum CHECK constraints were generated as comments, not real code

Every declared ErmAttribute.default was rendered as a // TODO default = "..." comment instead of a typed .default(...) call, and every ErmDataType.Enum-derived CHECK constraint — already enforced in the SQL migration — was left out of the generated Kotlin entirely, only a // Note: N check constraint(s) ... not emitted comment marking the gap. Both silently disagreed with what ErmSqlEmitter’s DDL actually declares, the same class of two-emitter drift the v0.48.0 FK fix closed for foreign keys. A downstream consumer’s Testcontainers-based CI caught this the moment the FK fix let it reach further down its table list.

Fix

ErmExposedEmitter now renders a typed .default(...) for Boolean/Integer/Real/Decimal and non-sanitized-literal Enum attributes — Varchar/Text/date-time/Uuid/Json/Custom/ externally-retrofitted-enum defaults keep the safe TODO-comment fallback, since there is no way to safely infer a typed literal for those. Every Enum-typed attribute now also gets its auto-derived CHECK constraint emitted via Table.check(name) { col.inList(EnumType.entries) }, named to match Postgres’s own auto-naming for the SQL side’s anonymous CHECK (<table>_<column>_check) — the same rationale ermDefaultForeignKeyConstraintName’s fkName fix already established for foreign keys.

sanitizeEnumConstantName moved to a new shared dev.kuml.erm.model.ErmEnumNaming (kuml-metamodel-erm), alongside a new ermEnumNeedsCustomMapping(values) predicate, so both emitters answer “does this enum need customEnumeration’s dbValue/fromDb mapping” from one source of truth instead of duplicating the logic.

Added ErmSqlEmitterTest/ErmToExposedTransformerTest regression coverage matching the precedent ErmSqlExposedFkAgreementTest already set for the FK fix.

One intentional exception

For an enum whose literals needed sanitizing into valid identifiers (e.g. "NOT_APPLICABLE"), Exposed 1.3.1’s schema-diff cannot recognize a default value round-tripped through customEnumeration’s toDb lambda — verified against a real Postgres container that it keeps proposing a SET DEFAULT/DROP DEFAULT statement regardless of whether the Table object declares a matching default or not. ErmSqlEmitter now skips the DDL-level DEFAULT clause for exactly these columns too, so both emitters agree (neither declares a default) rather than a database default Exposed’s own tooling can never confirm the generated code actually matches.

v0.48.x1 release
v0.48.02026-08-06

Fix: Exposed foreign keys now agree with the SQL they're generated from

ErmSqlEmitter and ErmExposedEmitter silently disagreed on foreign-key constraint names and referential actions for the same model — a drift class no kUML test could catch without a live database. Both emitters now agree explicitly, backed by a new golden-model regression test.

Fixed

kuml-codegen-m2m-exposed: generated reference()/optReference() calls silently disagreed with the FK constraints kuml-gen-sql actually writes to the database

ErmSqlEmitter (kuml-gen-sql) and ErmExposedEmitter (kuml-codegen-m2m-exposed) both derive a foreign key’s constraint name and referential actions from the same ErmModel, but never agreed on how. ErmSqlEmitter named constraints fk_<table>_<column> and correctly omitted ON DELETE/ON UPDATE clauses for ReferentialAction.NO_ACTION (an omitted clause means NO ACTION on Postgres/MySQL/H2 — the SQL-standard default). ErmExposedEmitter left fkName/onDelete/onUpdate off the generated reference()/optReference() call entirely for that same NO_ACTION case, which meant Exposed itself computed its own, different defaults at runtime: fk_<table>_<column>__<targetcolumn> naming, and RESTRICT as the Postgres dialect’s default reference option — not NO_ACTION.

A downstream consumer’s Testcontainers-based CI (a real Postgres container, migrated with the generated DDL) caught this the first time anything actually compared the migrated schema against the compiled Table objects via Exposed’s own SchemaUtils.statementsRequiredToActualizeScheme. No kUML test had ever done that comparison before — each emitter’s own tests only asserted its own output in isolation, so the two could disagree indefinitely without either suite noticing.

Fix

Extracted the shared naming convention into ermDefaultForeignKeyConstraintName in kuml-metamodel-erm — the single source of truth ErmSqlEmitter already used, now used by both emitters — and made ErmExposedEmitter always pass fkName, onDelete, and onUpdate to reference()/optReference() explicitly, including the NO_ACTION case, which now renders ReferenceOption.NO_ACTION instead of omitting the arguments.

Added ErmSqlExposedFkAgreementTest, a golden-model test that renders one ErmModel through both emitters and asserts they agree on every FK’s constraint name and referential actions — no live database required, closing the coverage gap that let this ship undetected.

Compatibility

This changes ErmExposedEmitter’s output only, not ErmSqlEmitter’s DDL. The new explicit fkName values match what ErmSqlEmitter has always named those constraints, so no rename migration is needed for anyone whose database already has this generator’s SQL applied — verified against a real, already-migrated production-adjacent schema before release.

v0.47.x1 release
v0.47.02026-08-05

Chocolatey package: kuml is now actually callable after install

`choco install kuml` reported success and deployed every package file correctly, but never created a `kuml` command anywhere on PATH — the install script wrongly assumed Chocolatey auto-shims `.bat` launchers the way it does `.exe` files. Fixed by registering the shim explicitly, the same way any other Chocolatey package ships a non-.exe launcher.

Fixed — no shim was ever created, so kuml was uncallable after a clean choco install

  • Chocolatey’s automatic shim generation only ever considers .exe files found under tools\; .bat/.cmd launchers are never picked up without an explicit Install-BinFile call. chocolateyInstall.ps1 assumed otherwise, so C:\ProgramData\chocolatey\bin\ stayed empty after install — confirmed via chocolatey.log: not a single shimgen.exe invocation occurred.
  • chocolateyInstall.ps1 now calls Install-BinFile explicitly for kuml.bat and, where present, kuml-mcp.bat/kuml-lsp.bat; chocolateyUninstall.ps1 tears the shims down again with matching Uninstall-BinFile calls.
  • If you installed an earlier version and kuml isn’t on PATH, choco upgrade kuml picks up the fix.
v0.46.x1 release
v0.46.02026-08-01

JetBrains plugin no longer requires the Kotlin plugin to load

`plugin.xml` declared a hard dependency on `org.jetbrains.kotlin`, so the IntelliJ Platform refused to load kUML at all on any IDE that doesn't bundle the Kotlin plugin — WebStorm, PyCharm, GoLand, Rider, CLion, DataGrip, RubyMine. That blocked even the Kotlin-independent features: the file icon and the live split-view SVG preview. The descriptor is now split so the Kotlin-plugin-free extensions always load, and the Kotlin-bound ones load only when the Kotlin plugin is actually present.

Fixed — hard org.jetbrains.kotlin dependency prevented the plugin from loading on any IDE without the Kotlin plugin

  • plugin.xml now declares only com.intellij.modules.platform as a hard dependency, plus the Kotlin-plugin-free extensions (file icon, split editor, settings page, live templates, export notifications).
  • A new config-file fragment, META-INF/kuml-kotlin-support.xml, is referenced via an optional="true" dependency and loaded by the platform only when the Kotlin plugin is present. It holds every extension bound to language="kotlin" (external annotator, structure view, folding, completion, rename) plus scriptDefinitionsSource.
  • Result: the plugin now installs and runs on every IntelliJ-Platform IDE. Script recognition, completion, structure view, folding, rename, and inline diagnostics continue to activate automatically wherever the Kotlin plugin is present; the file icon and split-view preview now also work where it is not.
v0.45.x1 release
v0.45.02026-07-30

Hardening the AI patch-editing engine for untrusted, multi-tenant use

kuml-ai-tools' structured model-patch engine (the tool-calling machinery behind the desktop app's AI assistant) gets a safety pass ahead of future server-side use: its optional render-verification phase is now pluggable with no unsafe default, so a caller can no longer accidentally enable it without an explicit, resource-bounded rendering strategy. Also two real hardening fixes found during that review: the expression parser could crash with a stack overflow on deeply nested input, and some validation paths had no upfront length check before parsing.

Changed — PatchValidator’s RENDER phase is now pluggable, with no unsafe default

  • The RENDER phase (an optional smoke-render pass over an applied patch) previously fell back to an unbounded, no-size-cap, no-timeout renderer whenever it was enabled — fine for a trusted, single-user desktop caller, a real denial-of-service risk for any future untrusted, multi-tenant one.
  • renderSmokeStrategy is now a nullable constructor parameter with no safe default; enabling the RENDER phase without one still compiles, but now fails fast with an exception at construction time instead of silently falling back to the unbounded renderer.
  • Trusted single-user callers (desktop, CLI) opt into the old behavior explicitly via the new PatchValidator.desktop(...) factory. A server-side caller supplies its own resource-bounded RenderSmokeStrategy instead.
  • This is a runtime-breaking change for any caller that relied on the old implicit default — old call sites still compile, but throw the first time they execute. Replace PatchValidator(renderSmokeEnabled = true) with PatchValidator.desktop().

Fixed — two defects found during this feature’s own review

  • The expression parser could crash with a stack overflow on deeply nested input. Attacker-controlled input with enough chained negations, nested parentheses, or nested function-call arguments overflowed the JVM call stack. Added a nesting-depth limit well above any legitimate expression’s depth.
  • Some validation paths parsed expressions with no upfront length check. A very long guard/action-body string could burn CPU in the parser before any other check ran. Added a length check that rejects oversized input before parsing starts.
v0.44.x1 release
v0.44.02026-07-29

New interpreter-dialect DSL printer for the class-diagram model

A new printer, InterpreterUmlModelDslPrinter, serializes a UML class-diagram model back to DSL source text in the strict grammar subset the execution-free InterpreterScriptEvaluator can parse — the existing printer's string-ID relationship syntax and stereotype operator aren't representable there. Useful for any integration that needs to round-trip a model through a sandboxed, non-executing evaluator rather than a full Kotlin compiler. Also two performance/robustness fixes found while building it: a deeply nested package hierarchy could crash the printer with a stack overflow, and diagrams with many comments could hit a quadratic slowdown. Both fixed and regression-tested.

Added — InterpreterUmlModelDslPrinter

  • Prints a UML class-diagram model as DSL source text that round-trips through InterpreterScriptEvaluator (the sandboxed, execution-free evaluator), unlike the existing UmlModelDslPrinter, whose string-ID relationship syntax and stereotypes += "..." operator the interpreter’s grammar cannot parse at all.
  • Uses a two-pass design: every classifier is declared as a val first, then relationships and comments are emitted referencing those vals — this correctly handles circular and self-referential structures without special-casing them.
  • Documents, and is tested against, exactly which fields survive the interpreter’s stricter grammar (relationships, attribute types, association details all round-trip) and which are always dropped on read-back instead (stereotypes and parameter/return-type classifier references have no representable syntax at all; enum/interface visibility, grid layout hints, attribute multiplicity, constraint details, parameter direction/defaults, and every relationship/comment ID are also dropped) — a printer whose own documentation and test suite are honest about that boundary, rather than a silent best-effort.

Fixed — two defects found during this feature’s own review

  • Deeply nested packages could crash the printer with a stack overflow. The printer’s internal nested-member count (used for a package’s “not serialized” notice) recursed once per nesting level; a sufficiently deep package chain overflowed the JVM call stack. Replaced the recursive walk with an iterative one.
  • Many comments could make printing quadratically slower. Resolving each comment’s anchor re-scanned the full comment-link list every time. Replaced with a single up-front grouping pass.
v0.43.x1 release
v0.43.02026-07-28

State-machine and activity-diagram rendering fixes, watermark API parity

Four rendering fixes to plain UML state-machine and activity diagrams, found against real Vault-example diagrams: long state names now wrap instead of overflowing their box, the opt-in "Powered by kUML" watermark now stays inside the diagram frame, long decision-edge guard labels widen the frame instead of running past it, and several transitions looping back into the same state no longer bunch their lines and labels into an illegible mess. Also: kuml-web's render API gained a `watermark` parameter, matching the CLI's existing `--watermark` flag.

Added — Opt-in watermark exposed through the kuml-web render API

  • The CLI’s --watermark flag (a small, theme-consistent “Powered by kUML” label, off by default) now has a matching watermark parameter on kuml-web’s POST /api/render — useful for any consumer of that API, such as the Obsidian plugin’s server render mode.

Fixed — UML state-machine diagrams: long state names overflowing their box

  • Simple states now wrap their name at word boundaries and vertically center the resulting text block; the box grows in height when needed. A single-line name renders byte-identical to before.
  • Composite states are unaffected — ELK already sizes those from their substates.

Fixed — UML state-machine diagrams: watermark rendered below/outside the frame

  • Plain UML state diagrams draw their outer frame differently from every other diagram type — as a layout group sized only to its own content, not through the generic canvas-covering frame every other diagram uses.
  • With the watermark on, “Powered by kUML” landed below that frame’s bottom edge instead of inside it. The state-machine frame now stretches to the same edge clearance the generic frame uses whenever the watermark is on.

Fixed — UML activity diagrams: long guard labels overflowing the frame

  • A decision edge’s [guard] label could run past the diagram’s left/right frame border. State machines already had a fix for this exact class of bug (widening the frame for overhanging transition labels); activity diagrams now get the matching fix — the canvas widens so a guard label’s estimated background rect always fits inside the frame.

Fixed — UML state-machine diagrams: back-edge lines and labels overlapping

  • A state with several transitions looping back into it from below (e.g. multiple distinct “reminder sent” transitions into the same waiting state) rendered with the return lines bunched only a few px apart, and their trigger-text labels overlapping into illegible text.
  • ELK’s edge-to-edge spacing for state diagrams widened (36px → 56px), and — the actual bug — back-edge labels now get proper collision detection: the overlap-clustering pass previously measured each edge’s natural route midpoint instead of the different, fixed point back-edges actually render their label at, so overlapping back-edges were never detected as colliding.
v0.42.x1 release
v0.42.02026-07-27

Smaller Windows packages — under Chocolatey's 200MB scan limit

kuml-mcp and kuml-lsp each shipped their own full copy of dependencies already bundled with the main CLI — including a ~60MB kotlin-compiler-embeddable.jar duplicated per sub-app — found while investigating why the v0.40.0 Chocolatey package needed a manual moderator review (its Windows runtime zip was 262MB, over VirusTotal's 200MB single-file scan limit). Jars that exactly match a jar already in the shared lib/ are now deduplicated, with both launcher classpaths rewritten accordingly. Result: the self-contained Windows runtime zip drops from 273MB to 188.6MB, and the JRE-less universal build from 240MB to 155.6MB — both comfortably under the scan limit going forward.

Fixed — Chocolatey/Windows package size: deduped jars shared between kuml-cli, kuml-mcp, and kuml-lsp

  • kuml-mcp and kuml-lsp are separate installDist outputs, each bundled with their own full lib/ — mostly overlapping with the main CLI’s, since all three depend on much of the same kuml-core-*/kuml-metamodel-*/kotlin-compiler-* graph.
  • Jars that exactly match (filename + byte size) a jar already in the shared lib/ are now deleted from the sub-app’s own lib directory, with both the Unix and Windows launcher classpaths rewritten to reference the shared copy instead.
  • Only exact matches are deduplicated — a differing filename means a genuinely different dependency version and is left untouched, so a version skew between modules can never cause the wrong jar to be picked up.
  • kuml-runtime-*.zip: 273MB → 188.6MB. kuml-universal-*.zip: 240MB → 155.6MB. Both now comfortably under VirusTotal’s 200MB single-file scan limit that Chocolatey’s automated review enforces.
v0.41.x1 release
v0.41.02026-07-23

UmlModelDslPrinter now covers the full UML class-diagram round-trip

The internal model-to-DSL-text printer used for layout-hint round-tripping previously covered only a subset of the class-diagram model — dependencies, OCL constraints, comments, non-default visibility, aggregation kind, association-level stereotypes, operation parameters, and association name/role/navigable were all silently dropped on export. Extended to emit all of these, validated with full data-class-equality round-trip tests rather than substring checks. No user-facing CLI/Desktop change — this is foundational work for the kUML Portal's upcoming real-time collaboration feature.

Added — UmlModelDslPrinter: full round-trip coverage for the UML class-diagram subset

  • Extended kuml-core-dsl’s model-to-DSL-text printer to emit dependencies, OCL constraints (with kind/contextOperation), comments (single- and multi-anchor), non-default visibility on every classifier kind, aggregation kind, association-level stereotypes, operation parameters, association name/role/navigable, and UmlTypeRef.referencedId for classifier-typed attributes/parameters/return types — previously all silently dropped on export.
  • UmlPackage/packageOf remains a deliberate scope cut (needs nested sub-package handling with documented edge cases), but a skipped package now emits a comment reporting exactly how many nested elements it would otherwise silently drop, instead of vanishing without a trace.
  • Fixed a real, previously-undocumented gap: attribute defaultValue/isStatic were never emitted at all — caught by an adversarial round-trip test (quotes, backslashes, $, embedded newlines) during independent review, fixed, and covered by dedicated regression tests.
  • Self-contained kuml-core-dsl library extension — no other module’s production code changed (only a new test in kuml-core-script, needed for the compiler-path round-trip oracle). This is the foundation for the kUML Portal’s upcoming CRDT-based real-time collaboration feature, which needs to reliably serialize a live-edited in-memory model back to DSL text.
v0.40.x1 release
v0.40.02026-07-23

Service Blueprint diagrams get pain-point captions and a touchpoint legend

Pain-point text used to exist only in a hover-only tooltip, invisible in PDF/PNG exports, and touchpoint names were never rendered anywhere — only the channel icon — so two touchpoints sharing a channel (e.g. two different push notifications) looked identical. Pain points now show a short, truncated caption right next to the pain dot; touchpoints get a small numbered badge on their icon, resolved by a new legend band below the grid that maps each number to its touchpoint's name. The legend wraps across as many rows as needed and the canvas grows to fit — diagrams without touchpoints render exactly as before.

Added — Service Blueprint: pain-point captions and a touchpoint-name legend

  • Pain points now render a short, single-line, truncated caption next to the existing pain dot, on its own row directly above the touchpoint-icon row — the full, untruncated text stays available via the tooltip.
  • Touchpoint names are no longer invisible: each touchpoint actually referenced by a visible step gets a small numbered badge on its icon, and a new legend band below the grid maps each number back to the touchpoint’s name.
  • The legend is keyed by individual touchpoint, not just symbol + channel, since two touchpoints can share both while meaning something different (e.g. two distinct push notifications).
  • Legend entries wrap across as many rows as needed and the canvas grows to fit — verified with an 18-touchpoint stress test with long names, wrapping cleanly across 6 rows with no clipping or overlap.
  • Diagrams with no touchpoints render exactly as before — no empty legend band appears.
v0.39.x1 release
v0.39.02026-07-22

Comment/Note support reaches every diagram type, three overflow bugs squashed

`comment(text = ..., anchors = ...)` — previously available on class, sequence, and state-machine diagrams — now works on all fourteen UML diagram types; the metamodel and renderer support was already generic, the only gap was nine diagram builders rejecting the relationship outright (two more allowed it only implicitly). The SDKMAN! candidate (still pending vendor onboarding — not yet installable) switches to a single universal (no-bundled-JRE) distribution, relying on the user's own Java 21+ instead of duplicating a bundled JRE five times over. Three independent text-overflow bugs are fixed: SysML 2 requirement boxes and use-case ellipses, plain UML use-case/actor labels, and Service Blueprint step cards all now size themselves to their actual text content instead of a fixed box size, so long titles no longer spill past the border.

Added — Comment/Note support extended to all remaining UML diagram types

  • comment(text = ..., anchors = ...) — introduced for class, sequence, and state-machine diagrams — now works on component, use-case, object, package, deployment, profile, composite-structure, activity, communication, timing, and interaction-overview diagrams too.
  • The metamodel (UmlComment, UmlCommentLink) and renderer/layout-bridge support were already generic across diagram types; the only gap was nine diagram builders’ internal addRelationship guards rejecting UmlCommentLink outright.
  • No new DSL surface was needed — all fourteen diagram types share the single UmlModelScope.comment() overload, so free-standing notes and dashed anchor lines now render identically everywhere.

Changed — SDKMAN! candidate switched to a universal (no-bundled-JRE) distribution

  • The SDKMAN! release (still pending vendor onboarding — not yet installable via sdk install kuml) now ships a single UNIVERSAL candidate instead of five platform-specific archives, matching how every other JVM candidate there (kotlin, gradle, scala, kotlin-toolchain, …) is distributed.
  • Chocolatey, Homebrew, and direct-download keep their self-contained jlink runtime bundle unchanged; SDKMAN! relies on the user’s own active Java 21+ instead of duplicating a ~56 MB bundled JRE five times over.

Fixed — Requirement-box and use-case ellipse text overflow in SysML 2 diagrams

  • A requirement box’s text-compartment height was estimated from text.length / 25, assuming pure character-count wrapping — the renderer’s actual word-boundary wrapping always produces a ragged right edge and therefore more lines than that predicts, so several requirement boxes rendered 1–2 lines taller than the box reserved for them and spilled past the bottom edge. The estimator now mirrors the renderer’s word-wrap algorithm exactly.
  • Use-case ellipses had a fixed 160px width regardless of name length; they now grow with the estimated label width, with extra padding since an ellipse only reaches full width at its vertical center.

Fixed — Use-case ellipse and actor-label overflow in plain UML use-case diagrams

  • The same fixed-size gap existed independently for plain UML: actors and use cases had no content-aware sizing at all and always got a fixed 160×80 box, even though both render a single-line, non-wrapping, centered label. Long names now size to their estimated label width instead of overflowing the shape.

Fixed — Service Blueprint step-card text overflow

  • Step-card row height was a hardcoded constant regardless of title length, and long titles wrapping onto multiple lines were vertically re-centered in a way that pushed 3+ line titles above the card’s top border — titles wrapping to 6+ lines ran past the bottom border too. Row height is now content-aware, growing to fit the tallest wrapped title anywhere in the diagram, and titles are always top-anchored with room to spare.
v0.38.x1 release
v0.38.02026-07-20

Every SVG now carries a kUML signature, and OKF workspaces gain a convert command

Three previously separate waves — branding, OKF workspace tooling, and a Desktop UI/UX pass — land together as a single v0.38.0, since none of the intermediate versions were ever tagged or announced on their own. Every rendered SVG now carries a "Generated by kUML" attribution comment, plus a new opt-in `--watermark` flag for a visible "Powered by kUML" label. A new `kuml workspace convert` command bridges OKF knowledge-workspace notes and bare `.kuml.kts` engineering scripts, and a new handbook page documents using an Obsidian vault as an OKF workspace. The Desktop app gains real undo/redo, SVG/PNG export, an unsaved-changes guard on file-tree navigation, and several other items from the design-team review's action list. Also fixed: Blueprint sample-output PNGs silently stopped generating once the attribution comment landed, plus a defense-in-depth escaping fix for watermark text.

Added — “Powered by kUML” attribution comment + opt-in watermark

  • Every rendered SVG now carries an always-on metadata comment — <!-- Generated by kUML v0.38.0 — kuml.dev --> — independent of the existing theme-debug comment.
  • A new opt-in visible watermark (SvgRenderOptions.watermark, default false) grows the canvas downward by a small band below the existing padding, so it structurally cannot overlap diagram content, with a narrow-canvas guard that widens the canvas when needed.
  • Wired end-to-end: a --watermark flag on kuml render (CLI), a kuml { watermark.set(true) } Gradle plugin extension property, and a new optional parameter on KumlPngRenderer so the watermark reaches PNG rasterization too.
  • MCP stays off by construction (no change needed); Blueprint diagrams get the attribution comment but not the watermark, since Blueprint’s renderer takes no SvgRenderOptions.

Added — kuml workspace convert — bridge between OKF notes and .kuml.kts scripts

  • New subcommand kuml workspace convert <src> --to okf|kts converts between OKF knowledge-workspace Markdown notes and bare .kuml.kts engineering scripts — the two formats share identical DSL text, so “convert” is a text wrap/unwrap operation, not a model re-serialization.
  • kts -> okf -> kts round-trips the DSL text losslessly; okf -> kts -> okf is lossy by design — prose and non-diagram documents (Concept, Article, Glossary, …) don’t survive the reverse direction.
  • New finding codes OKF-C-001..OKF-C-004 cover skipped prose documents, multi-block splits, un-mappable diagram kinds, and evaluation/write failures, with --strict escalating warnings to errors.
  • --force, --output, and -o text|json match the existing workspace info/validate/render conventions.

Added — Obsidian Sync handbook page

  • A new handbook page documents using an Obsidian vault as an OKF knowledge workspace: the recommended kuml workspace validate/render --mirror loop, the wikilink caveat (workspace tooling only parses Markdown-form links, not Obsidian [[wikilinks]]), frontmatter compatibility, and how workspace convert bridges a vault to a plain engineering repository of scripts.

Changed — Desktop: design-team review action list implemented

  • Unsaved-changes guard now applies to file-tree navigation, not just File → New/Open/Quit — switching files with unsaved edits now prompts Save/Discard/Cancel.
  • Real Undo/Redo, wired to the editor’s built-in undo manager, with Ctrl+Z / Ctrl+Shift+Z accelerators.
  • File menu gains Export SVG… and Export PNG…, both disabled until a diagram has actually been rendered.
  • Preview pane gets a Zoom In / Zoom Out / Reset 100% / Fit control strip.
  • Plugin Manager and the AI input placeholder now route through the i18n system instead of hardcoded German literals mixed with English tab labels.
  • Help → About now shows a dialog; Help → Documentation opens kuml.dev/docs; Find… is disabled rather than a clickable no-op.

Fixed — Blueprint sample-output PNGs stopped generating after the attribution comment landed

  • The PNG-inspection helper only side-rendered a PNG when SVG content started with <svg or <?xml; once Blueprint SVGs started with the attribution comment instead, PNG generation silently stopped. Fixed to also accept a leading XML comment wrapping an <svg> root.

Security — Defense-in-depth: escape theme-derived strings in the watermark’s <text> element

  • The watermark interpolated theme font-family and color strings raw into the <text> element, bypassing the escaping convention every other text emitter follows. Not exploitable today (values are structurally constrained), but fixed to close a latent injection vector against any future feature sourcing theme strings from less-trusted input.
v0.37.x1 release
v0.37.02026-07-19

kuml-lsp is finally shipped, kuml-vscode gets its own repo

kuml-lsp — the editor-agnostic language server behind diagnostics and completion in the VS Code extension — was buildable from source only until now; it ships in the Homebrew formula, the GitHub release zip, and Chocolatey for the first time, the same way kuml-mcp already did. Two bugs found while wiring that up are fixed alongside it: the server no longer leaks a zombie process on client disconnect, and the release zip no longer ships it without its executable bit. The kuml-vscode extension itself moves into its own repository, matching the existing obsidian-kuml pattern. Also fixed: a false positive in OKF Workspaces link validation for root-absolute links, plus a UI/UX pass on the Desktop app's Knowledge Workspace screens and a new backlinks index.

Added — kuml-lsp now shipped in the runtime zip (Homebrew, GitHub release, Chocolatey)

  • kuml-language-server has been a fully working Gradle module for a while, but was never wired into any actual distribution channel — every real install of the kuml-vscode extension hit ENOENT: spawn kuml-lsp unless the user had a local kUML repo clone with a Gradle build lying around.
  • Bundled the same way kuml-mcp was: a lsp/ subtree in the runtime image plus a thin bin/kuml-lsp wrapper (and Windows .bat counterpart).
  • The Homebrew formula installs and smoke-tests it identically to kuml-mcp.

Added — kuml-vscode extracted into its own repository

  • The VS Code extension (TypeScript/npm) lived inside the Kotlin/Gradle monorepo as kuml-vscode-plugin/, inconsistent with obsidian-kuml’s already-established pattern of a separate repo.
  • Extracted with full git history to kuml-dev/kuml-vscode — own npm/vsce release cadence, independent of core kUML version numbers going forward.

Fixed — VS Code handbook page described a stale v0.1.0-era extension

  • The handbook’s VS Code page still said “no Language Server” and listed diagnostics, completion, and live-preview as “V2 — not yet built”, even though kuml-vscode v0.2.0 had already shipped an LSP client and a live-preview webview.
  • Rewritten against the real feature set: a Requirements section for the two external binaries it depends on, all 7 actual settings instead of 3, and the live-preview’s dual HTTP/CLI render strategy.

Fixed — kuml-lsp process leak on client disconnect

  • The language server never exited on its own once its input stream reached EOF (the signal a client sends when it disconnects) — lsp4j’s dispatch machinery keeps non-daemon threads alive past the listening call returning.
  • Fixed with an explicit clean shutdown once listening ends, so the process can’t outlive the editor that spawned it.

Fixed — release zip shipped kuml-lsp without its executable bit

  • The permission allowlist that preserves Unix executable bits inside the generated runtime zip wasn’t extended for the new lsp/ paths, so bin/kuml-lsp would have shipped non-executable in the zip itself — masked for Homebrew users only because the formula applies its own explicit chmod, but broken for anyone downloading the zip directly.
  • Caught by an independent review pass before release, not by manual testing (which ran against the local build staging directory, not the actual zip artifact).

Fixed — Chocolatey installer double-shim risk for kuml-lsp

  • The installer only suppressed the duplicate shim Chocolatey would otherwise create for kuml-mcp’s nested launcher; added the equivalent handling for kuml-lsp.
  • Link validation resolved every Markdown link relative to the source document’s own directory, including root-absolute targets like /notes/foo.md, producing false-positive broken-link findings for links the workspace’s own link handler already resolved correctly.
  • The Trust dialog’s confirm action is now a filled primary button, reflecting that it gates arbitrary script execution.
  • The workspace-mode chooser now visually distinguishes Knowledge Workspace (the declared “hero mode”) from Engineering mode, instead of both looking like identical plain buttons.
  • Document type-badge glyphs in the workspace tree now carry a hover tooltip.
  • New bidirectional link index: the Desktop app now shows a “Linked from” backlinks footer per document — the first time cross-workspace navigation works in both directions, not just forward via link clicks.
v0.36.x2 releases
v0.36.12026-07-17

BPMN box overflow, UML label collisions, and a repo-wide ktlint gap closed

Five rendering fixes: BPMN task/subprocess/call-activity boxes now size to their label instead of a fixed 120×60 box (previously overflowing on longer text), a UML state-machine frame now widens for overflowing transition labels instead of clamping them, abstract UML class names are now italicized per UML 2.5 instead of a fake «abstract» line, converging UML association/link endpoint labels now fan out instead of stacking, and sequence-diagram lifeline ordering is now preserved across all five remaining render pipelines (previously only the CLI). Also closes a build gap where ktlint silently never ran on any kotlin.multiplatform module.

Fixed — BPMN: content-aware sizing for task/subprocess/call-activity boxes

  • BPMN Task/SubProcess/CallActivity boxes rendered at a fixed 120×60 size regardless of label length, so longer labels overflowed the box on both sides.
  • New BpmnContentSizeProvider grows box width with label length (floored at 120px, capped at 480px), modeled on the same character-width heuristic already used for UML classes.
  • Wired into every production render pipeline (CLI, Web, Desktop, AsciiDoc, Gradle plugin) — the initial fix only covered the CLI.
  • Also fixes expanded BPMN SubProcess frames overflowing when their content-driven minimum size exceeds the initial ELK layout.

Fixed — UML state machines: widen frame for overflowing transition labels instead of clamping

  • A transition label routed through a narrow corridor near the frame’s left border could push its background past the frame edge — the frame now widens by exactly the overhang instead of clamping the label inward.
  • Two transitions converging on the same final state now share a baseline anchor for their label-stacking offset, so the intended vertical gap between them no longer collapses to a few pixels.

Fixed — UML: italicize abstract class names instead of fake «abstract» line

  • UML 2.5 marks abstract classifiers by italicizing the name, not via a fake «abstract» stereotype line — fixed across the SVG renderer, the layout-sizing pass, and the Compose desktop viewer.
  • Role-name and multiplicity labels on UML associations/links no longer stack on top of each other when several relationships converge on the same node border — they now fan out along the border, matching the existing ERM/Chen cardinality-label fix.

Fixed — sequence diagrams: preserve lifeline order everywhere

  • LayoutHints.preserveNodeOrder was already pinned for sequence diagrams in the CLI pipeline; now wired into the Gradle plugin, Web, Desktop, MCP and AsciiDoc/Markdown pipelines too, so lifelines keep their declared order on every render path.

Fixed — build: ktlint now covers all kotlin.multiplatform modules

  • ktlint was only hooked to org.jetbrains.kotlin.jvm, so ~19 multiplatform modules (kuml-io-svg, kuml-layout-bridge, kuml-desktop, kuml-widget-compose, and others) were never linted by check. Now closed, with the formatting drift it exposed cleaned up.
v0.36.02026-07-14

Sequence & activity diagram fixes: labels, guards, orientation, sizing

Six related sequence-diagram rendering fixes (content-aware lifeline width, guard label z-order and spacing, uniform label backdrop color, preserved lifeline order) plus two activity/state diagram fixes (orientation now actually affects layout direction, content-aware action-node sizing) — all found while producing real external-publication renderings. Also hardens the release pipeline's GitHub Release upload against a transient GitHub API failure observed on v0.35.0, and adds a Code of Conduct.

Fixed — sequence diagrams: content-aware lifeline width, guard z-order, label color, node order

  • Lifeline header boxes now size to the participant name instead of a fixed 140px width — long names no longer overflow the box edge.
  • Combined-fragment guard labels (LOOP/BREAK/ALT [guard] text) now paint after lifelines instead of before, so a lifeline’s dashed line no longer crosses through guard text.
  • Label backgrounds are threaded through a canvasBackgroundFill parameter instead of hardcoded white — labels inside a tinted combined-fragment now blend into that fragment’s own fill.
  • Fixed a latent ELK layout bug: sequence-diagram lifelines have no edges between themselves, so ELK repacked them by size instead of declaration order once widths stopped being uniform. New opt-in LayoutHints.preserveNodeOrder, wired for sequence diagrams in the CLI render pipeline.

Fixed — sequence diagrams: uniform label backdrop + guard/pentagon spacing

  • Root cause of “some labels blue, some white”: combined-fragment frame rects carry both a CSS class and a fill presentation attribute, and the stylesheet rule always wins per the CSS cascade — so a fragment’s intended tint never actually rendered. All sequence-diagram label backgrounds now uniformly use the theme’s effective node fill, the color that is actually rendered.
  • Fixed guard labels ([k ≤ 3]) overlapping the LOOP/BREAK pentagon operator tag by a few pixels, for both the first operand and subsequent ALT/PAR branch operands.

Fixed — activity/state diagrams: orientation now affects layout direction, content-aware action sizing

  • ActivityDiagramConfig.orientation / StateDiagramConfig.orientation were dead DSL properties with zero effect on the render — orientation = ActivityOrientation.LEFT_RIGHT now genuinely produces a horizontal layout.
  • ACTION/OBJECT activity nodes no longer get a hardcoded 160×60 box regardless of label length; sizing now reuses the same text-width heuristic as classifier boxes.

Fixed — release pipeline: retry gh release upload on transient GitHub API failure

  • The v0.35.0 release’s linux-aarch64 runtime-upload leg hit a one-off “release not found” from gh release upload despite the release having been published minutes earlier — likely a GitHub API read-after-write consistency delay. All three “upload to existing GitHub Release” steps now retry up to three times with backoff.

Added — Code of Conduct

  • Adds CODE_OF_CONDUCT.adoc (Contributor Covenant 2.1), fulfilling the Kotlin Foundation grant requirement that grant recipients have a Code of Conduct in place.
v0.35.x1 release
v0.35.02026-07-14

«Index» stereotype for composite indexes and unique constraints

A new repeatable class-level `«Index»` stereotype closes the last UML-profile gap in the ERM mapping surface — composite/multi-column indexes and multi-column `UNIQUE` constraints, previously only reachable from the ERM-first Kotlin DSL. Found wiring up the ERM→SQL/Flyway branch of Lapis Cloud's MDA pipeline for the first time: retroactively regenerating all 9 domain migrations from the model surfaced 11 composite `UNIQUE` constraints and 40 standalone indexes with no UML-profile equivalent. Also ships two bug fixes found in the same real-world regeneration run.

Added — «Index» stereotype: composite/multi-column index and unique-constraint declaration

  • «Column».unique only covers single-column uniqueness — there was no way to declare a composite UNIQUE constraint or a standalone multi-column performance index from a UML class diagram, even though the underlying ErmIndex/EntityBuilder.index() machinery already supported it.
  • New repeatable class-level «Index» stereotype (columns: List<String>, unique: Boolean default false, name: String optional) — apply once per index a class needs.
  • Resolved in a new post-entity-construction pass (UmlToErmTransformer.resolveIndexes, mirroring resolveColumnLevelForeignKeys), placed after association resolution so it sees the entity’s final attribute set including association-derived FK columns.
  • An unresolvable/empty column list fails the transform loudly instead of silently producing a smaller index. Flows through ErmSqlEmitter/ErmExposedEmitter unchanged.

Fixed — index resolution ordering

  • resolveIndexes now runs after association resolution, not before: an «Index» column can be an association-derived FK column that only exists once mapAssociation has run — resolving indexes first meant such columns didn’t exist yet, failing with “does not exist on entity” for a column that legitimately would exist by the time the model is fully built.

Fixed — string-shaped DEFAULT values are now quoted

  • ErmAttribute.default always holds the plain semantic value (e.g. "GREMIUM_QUORUM"), never pre-quoted SQL literal syntax. The SQL emitter interpolated it verbatim regardless of column type, so a Varchar/Enum/Text default rendered as a bare, invalid identifier (DEFAULT GREMIUM_QUORUM) instead of a string literal (DEFAULT 'GREMIUM_QUORUM'). Embedded single quotes are now escaped by doubling.
v0.34.x1 release
v0.34.02026-07-14

Column-level FK override, KMP-friendly UUID/date-time representation, external enum types

Four fixes/features found while actually flipping a real project's production persistence layer over to kUML-generated code (Lapis Cloud), not just verifying against it: a `«Column».fkEntity`/`fkAttribute` tag that pins an explicit foreign key on a plain attribute when the real column name doesn't match association-derived naming, `uuidRepresentation`/ `dateTimeRepresentation` transform options for Kotlin Multiplatform projects where `java.util.UUID`/`java.time.*` don't exist on Kotlin/JS, an external-enum-type escape hatch (`«Column».enumType`) for enums shared across an RPC boundary, and a `DECIMAL(p,s)` sqlType override fix.

Added — «Column».fkEntity/fkAttribute: column-level FK override

  • UmlToErmTransformer’s association-to-FK derivation always names the generated column snake_case(singular(targetClass.name)) + "_id" (e.g. member_id), with no way to produce a differently-named real column (e.g. a real created_by referencing member.id) short of a role-name collision.
  • The new «Column».fkEntity (target class name) and optional «Column».fkAttribute (target column name, defaults to the target’s primary key) tags let a plain attribute pin an explicit FK target directly, bypassing association derivation entirely.
  • Resolved in a new post-entity-construction pass, so the target class may be declared anywhere in the diagram, including forward references. An unresolvable fkEntity/fkAttribute fails the transform loudly instead of silently leaving the column unreferenced.
  • Flows through ErmExposedEmitter/kuml-gen-sql unchanged, since both key off ErmAttribute.foreignKey regardless of its origin.
  • Found while actually flipping Lapis Cloud’s production persistence layer over to generated code: dozens of real FK columns across seven domains had no ErmForeignKey at the model level — harmless while the model was verification-only, but breaking every generated-code innerJoin() that relied on implicit FK resolution once the generated code became the real runtime table.

Added — uuidRepresentation / dateTimeRepresentation transform options

  • Two new opt-in TransformContext.options for erm-to-exposed: uuidRepresentation ("java" default, "kotlin") renders Uuid columns via kotlin.uuid.Uuid + Exposed’s uuid(...) instead of java.util.UUID + javaUUID(...).
  • dateTimeRepresentation ("java" default, "kotlin") renders Date/Timestamp columns via kotlinx.datetime.LocalDate/LocalDateTime instead of java.time.*.
  • Needed by any Kotlin Multiplatform (JVM+JS) project, since java.util.UUID/java.time.* don’t exist on Kotlin/JS — found during the same Lapis Cloud (KMP Ktor/Exposed) production swap.

Added — «Column».enumType: external enum type

  • Every UML enum-typed attribute previously always generated its own local Kotlin enum class in the Exposed output — no way to point a column at an already-existing enum shared across an RPC boundary.
  • The new «Column».enumType tag (fully-qualified name) sets ErmDataType.Enum.externalFqName; the Exposed emitter then imports and references that external type instead of emitting its own enum class.
  • Same commit also teaches UmlErmTypeMapper.mapOverride to recognise an explicit VARCHAR(n)-shaped sqlType override, mapping it to ErmDataType.Varchar(n) instead of falling through to ErmDataType.Custom.

Fixed — DECIMAL(p,s) sqlType override

  • A «Column».sqlType = "DECIMAL(p,s)" override with an explicit precision/scale fell through to ErmDataType.Custom (rendered as a generic text(...) fallback) — only the bare "decimal"/"bigdecimal"/"money" keywords were recognised, with a fixed default of Decimal(19, 2).
  • Now mirrors the existing VARCHAR(n) override handling, mapping to ErmDataType.Decimal(p, s) directly.
v0.33.x1 release
v0.33.02026-07-13

ERM mapping profile: kotlinObjectName tag for UML class diagrams

Closes a DSL-completeness gap found during a second real MDA retrofit attempt against Lapis Cloud: the ERM Kotlin DSL already let a model override the generated Kotlin identifier for an Exposed `Table` object, but the UML mapping profile — the surface most class-diagram authors actually use — had no equivalent tag, so the override was unreachable. `«Entity»` now accepts an optional `kotlinObjectName` tag, propagated by `UmlToErmTransformer` through to the generated Exposed artifacts, with identical effect to the ERM-DSL path.

Added — kotlinObjectName tag on the ermMappingProfile «Entity» stereotype

  • The ERM Kotlin DSL’s EntityBuilder.kotlinObjectName(name) override (v0.32.0) is now also reachable from UML class diagrams via «Entity»(tableName = ..., kotlinObjectName = ...).
  • UmlToErmTransformer reads the new tag and propagates it through ErmMetadataKeys/MutableErmEntity into the generated Exposed code — the physical table name still always follows the entity name; only the generated Kotlin identifier changes.
  • Found and closed during a real second retrofit attempt against an external Kotlin/Exposed project: all of its hand-written Exposed Table objects use an XxxTable naming convention that the mechanical PascalCase default can’t produce, and the project’s models are authored in UML via the mapping profile, not the ERM DSL directly.
v0.32.x1 release
v0.32.02026-07-13

ERM→Exposed retrofit fixes: Exposed 1.x imports, enum columns, overridable object names, Gradle plugin publishing infra

A real-world MDA retrofit attempt against an external project surfaced four concrete gaps in the UML→ERM→Exposed pipeline (ADR-0016), all closed in this release. Generated Exposed code now targets the current `org.jetbrains.exposed.v1.*` package layout instead of pre-1.0 paths, so it actually compiles against Exposed 1.3.1. Enum-typed UML attributes now generate a real Kotlin enum class + `enumerationByName<T>(...)` column instead of degrading to `Varchar`. Generated Exposed `Table` object names are overridable per entity via `kotlinObjectName(...)`, so retrofits can match existing call sites instead of the mechanical PascalCase default. And the `dev.kuml` Gradle plugin is now wired for publication to the Gradle Plugin Portal and Maven Central — the publish itself is still pending Plugin Portal API key onboarding, so build it locally via `publishToMavenLocal` in the meantime.

Added — enum column support across the UML→ERM→Exposed/SQL pipeline

  • UML enumeration-typed properties now map to a new ErmDataType.Enum instead of silently degrading to Varchar.
  • SQL generators render it as VARCHAR(longest literal) plus a CHECK (col IN (...)) constraint on every dialect.
  • The Exposed generator emits a companion Kotlin enum class referenced via enumerationByName<T>(...).
  • Human-readable literals (e.g. "In Progress") that aren’t valid Kotlin identifiers are sanitized into PascalCase constants, backed by a dbValue field so the physical column still stores the original literal.

Added — overridable Kotlin object names for generated Exposed tables

  • New kotlinObjectName(name) DSL method lets a model override just the generated Kotlin identifier for a table object (e.g. MemberTable instead of the mechanical Member).
  • The physical table name always still follows the entity name — only the in-code identifier changes.
  • Validated as a Kotlin identifier, propagates correctly into generated foreign-key references, and still participates in collision detection.

Added — Gradle plugin publishing infrastructure

  • The dev.kuml Gradle plugin is now wired for publication to the Gradle Plugin Portal and Maven Central.
  • Not yet live — the CI publish step is gated on Plugin Portal API key secrets that aren’t configured yet; it skips gracefully in the meantime. Use ./gradlew publishToMavenLocal from source until the Portal listing goes live.

Fixed — Exposed code generator retargeted at the Exposed 1.x package layout

  • Generated imports and reference()/optReference() calls now target org.jetbrains.exposed.v1.core.* instead of the pre-1.0 org.jetbrains.exposed.sql.* paths, matching Exposed 1.3.1’s API — generated code compiles again against the current Exposed stack.
  • UUID columns keep rendering via javaUUID(...) rather than Exposed 1.x’s own uuid(), preserving the documented type-mapping contract.
v0.31.x1 release
v0.31.02026-07-11

Knowledge Workspaces: kuml-workspace core module, workspace init scaffold + read-only Desktop viewer

Four waves land the first cut of Knowledge Workspaces (ADR-0011). The OKF workspace core (`Frontmatter`, `OkfDocument`/`OkfWorkspace`, `OkfType`, `OkfValidator`, `WorkspaceScanner`) moves out of `kuml-cli` into a new, reusable `kuml-docs:kuml-workspace` module, and the `type:` vocabulary grows from 16 to 29 entries — 8 SysML 2, 4 BPMN, and 1 Service Blueprint diagram type — backed by a machine-readable JSON contract and a stricter `kuml workspace validate --strict-vocabulary` mode with did-you-mean suggestions for near-miss types. New `kuml workspace init --mode knowledge|engineering` scaffolds a fresh OKF workspace — five starter files that pass validation and render cleanly in knowledge mode, a bare TOML marker plus a starter script in engineering mode — through a shared scaffold engine also now used by `kuml plugin init`. A fictional, self-contained Bürgerverein e.V. sample workspace under `kuml-examples` demonstrates the full scan → validate → render pipeline as a regression guard. Finally, kUML Desktop gains a read-only "File → Open Workspace..." viewer: a three-pane Knowledge Workspace view (document tree, rendered Markdown, live SVG preview) for knowledge-mode workspaces, or a familiar file tree into the single-file editor for engineering-mode ones — gated behind a mandatory "Trust this workspace?" dialog before any kuml-block script is evaluated from disk.

Added — kuml-workspace core module + OKF type vocabulary 16 → 29 (ADR-0011 FT-2, V3.6.1)

  • Extracts the OKF workspace core (Frontmatter, OkfDocument/OkfWorkspace, OkfType, OkfValidator, WorkspaceScanner) out of kuml-cli into a new kuml-docs:kuml-workspace module with an explicit public API — reusable from the Desktop viewer and a future standalone kuml-okf-types artifact.
  • The OkfType type: vocabulary grows from 16 to 29 entries: 8 SysML 2 types, 4 BPMN types, and 1 Service Blueprint diagram type, each requiresKumlBlock=true, with since/description metadata and a VOCABULARY_VERSION constant.
  • A machine-readable contract at src/main/resources/okf/kuml-okf-vocabulary.json is kept in lockstep with the enum by a bijective parity test.
  • The tolerant mode-only TOML regex is replaced by a hand-rolled WorkspaceMarkerParser covering the full [workspace]/[okf] marker subset (mode, name, kuml-version, version, vocabulary, strict).
  • New kuml workspace validate --strict-vocabulary escalates an unrecognised type: (OKF-W-002) from WARNING to ERROR, with a Levenshtein-based did-you-mean suggestion for near-miss type values.
  • New “Knowledge Workspaces” handbook page documents the marker format, the full vocabulary table, and the OKF-* finding codes.

Added — kuml workspace init scaffold + shared CLI scaffold engine (ADR-0011 FT-4, V3.6.2)

  • New kuml workspace init --mode knowledge|engineering --name <name> scaffolds a fresh OKF workspace.
  • knowledge mode (the default) writes a 5-file starter set — .kuml-workspace.toml, index.md (type: KumlWorkspace), an Article, a UmlClassDiagram with a minimal example diagram, and a Glossary — that passes kuml workspace validate with zero findings and renders cleanly.
  • engineering mode writes a bare .kuml-workspace.toml, a starter <slug>.kuml.kts script, and a .gitignore.
  • The {{var}} template engine and file-writing loop previously private to kuml plugin init are extracted into a shared dev.kuml.cli.scaffold.Scaffolder engine, so both commands render templates and enforce the non-empty-target-dir --force guard the same way; PluginScaffolder now delegates to it with no behavior change.
  • Fixes a code-injection-adjacent bug caught during review: the user-supplied workspace name was interpolated unescaped into generated Kotlin/kuml script content — the scaffold now escapes it correctly for Kotlin string-literal context.

Added — fictional sample-association Knowledge Workspace demo + rot-guard test (V3.6.3)

  • Adds a self-contained, fictional Bürgerverein e.V. OKF knowledge workspace under kuml-examples as a scan+validate+render demo of the kuml-workspace core.
  • sample-association-charter/ ships a .kuml-workspace.toml marker plus articles/, concepts/, glossary/, and models/ documents covering a fictional association’s charter, membership lifecycle, organs, and dispute resolution — three OKF models (class + state diagrams) embedded as ```kuml``` blocks.
  • A new SampleAssociationWorkspaceTest + WorkspaceExampleRenderer scans the workspace with WorkspaceScanner, validates it with OkfValidator, extracts diagrams via KumlScriptHost/DiagramExtractor, and renders them through the layout/theme pipeline as a rot-guard against regressions in the workspace core or renderer pipeline.

Added — kUML Desktop: read-only Knowledge Workspace viewer (V3.6.4)

  • Adds “File → Open Workspace…” to kUML Desktop: a directory chooser that mode-detects via WorkspaceScanner and opens either a three-pane Knowledge Workspace view (document tree | rendered Markdown | live SVG preview for kuml-blocks, reusing DesktopRenderPipeline) or, for Engineering workspaces, a symmetric file tree that loads a selected .kuml.kts into the existing single-file editor.
  • Unknown-mode directories show a chooser dialog per the ADR-0011 fallback rule.
  • Markdown rendering uses a minimal custom renderer (org.jetbrains:markdown-based) rather than the originally proposed multiplatform-markdown-renderer dependency.
  • ERM diagrams in a Knowledge Workspace show a clear “not yet supported in Desktop” message instead of crashing.
  • Internal document links navigate the tree selection via a new WorkspaceLinkHandler seam (external links open the system browser).

Security — mandatory trust dialog before any kuml-block evaluation

  • Opening a Knowledge Workspace in kUML Desktop can evaluate kuml-block scripts from disk. A mandatory “Trust this workspace?” dialog (WorkspaceTrust, TrustDialog) now gates all kuml-block evaluation on first open of a workspace root, with the decision persisted per path in AppSettings so it isn’t re-asked.
  • No kuml-block can be rendered before trust is confirmed.
v0.30.x2 releases
v0.30.12026-07-11

ERM Chen notation: cardinality label collisions at hub entities fixed

Chen-notation `1`/`N` cardinality labels rendered incorrectly in the SVG renderer: the source-side along-edge offset direction was inverted, landing labels inside the entity box on top of its title; labels had no perpendicular offset, so they straddled the connector line; and they lacked the halo pass already used by every other ERM edge label, making them unreadable wherever they crossed a line. Cardinality labels now route through a new shared `renderErmCardinalityLabel` helper with deterministic per-hub stacking, so labels converging on the same hub entity (multiple relationships meeting at one entity) fan apart instead of overlapping.

Fixed — ERM Chen notation cardinality label collisions at hub entities

  • Corrected the inverted source-side along-edge offset that landed 1/N cardinality labels inside the entity box, on top of its title.
  • Added a perpendicular offset component so labels no longer straddle the connector line.
  • Cardinality labels now get the same halo pass as every other ERM edge label, keeping them readable wherever they cross a line.
  • Labels converging on the same hub entity now fan apart via deterministic per-hub stacking, plus a bounded clearance guard against residual title overlap.
v0.30.02026-07-11

ERM rendering fixes, PostGIS/TimescaleDB codegen hooks + additive schema-diff migrations

Three ERM rendering fixes land together: compartment dividers (entity/view, all four notations) now sit at the top of their gap instead of cutting through the next row, self-referencing relationships route through the same self-loop router used by UML/C4 diagrams instead of ELK's cramped raw route, and SVG frame labels report the specific notation (`erm/martin`, `erm/bachman`, `erm/chen`, `erm/idef1x`) instead of an ambiguous shared `erm`. The widened FK-hub layout spacing for dense ERM entities is now a single shared constant referenced by every render path — CLI, web playground, and Asciidoctor handbook rendering — so `dump-json` can no longer diverge from `render`. On the codegen side, the SQL and Exposed generators gained two new extension hooks: PostGIS geometry columns (`geometry(Point|LineString|Polygon|Geometry[,SRID])`) and TimescaleDB hypertable declarations via a new `hypertable(timeColumn, chunkInterval?)` DSL method — both Postgres-only, both additive to the existing type system rather than a new `ErmDataType` variant. Finally, `kuml generate --sql-migration` computes the delta between two ERM model snapshots and writes a single Flyway-named migration containing only safe, additive DDL — any destructive or ambiguous change is refused up front with the complete list of blockers, rather than a fix-one-rerun-repeat loop.

Fixed — ERM compartment dividers, self-loop routing, and per-notation frame labels

  • Entity/view compartment dividers now sit at the top of their gap instead of the midpoint, so they no longer visually cut through the first row of the next compartment — across Martin, Bachman, IDEF1X, and the view query-preview divider.
  • ERM self-referencing relationships (e.g. a Category table’s “subcategory of” self-FK) now route through the same self-loop router used by UML/C4 diagrams instead of ELK’s cramped raw route, fixing role-label collisions in Martin/Bachman/IDEF1X notation.
  • SVG frame labels now report the specific notation (erm/martin, erm/bachman, erm/chen, erm/idef1x) instead of a shared, ambiguous erm.
  • The widened FK-hub layout spacing for dense ERM entities is now a single shared constant (ErmLayoutBridge.WIDENED_SPACING_HINTS), referenced by every production render path — CLI (render and dump-json), web playground, and Asciidoctor handbook rendering — closing a gap where dump-json used to diverge from render.

Added — PostGIS and TimescaleDB codegen hooks for SQL/Exposed

  • CustomTypeHooks recognizes ErmDataType.Custom raw strings shaped like geometry(Point|LineString|Polygon|Geometry[,SRID]) through an anchored, keyword-whitelisted, SRID-length-capped regex.
  • ErmSqlTypeMapper normalizes matching columns to their canonical Postgres type (Postgres-only, other dialects unaffected); ErmExposedEmitter renders a dependency-free geometry(name, sqlType) column call.
  • New ErmMetadataKeys.HYPERTABLE and EntityBuilder.hypertable(timeColumn, chunkInterval?) DSL method mark an ERM entity as a TimescaleDB hypertable. ErmSqlEmitter emits SELECT create_hypertable(...) right after CREATE TABLE (Postgres-only); the Exposed emitter adds an explanatory comment only, since Exposed has no native equivalent. The free-text chunkInterval value is whitelist-validated before interpolation into SQL.
  • Both hooks add to the existing type system rather than introducing a new ErmDataType variant or a runtime plugin SPI.

Added — additive-only SQL schema-diff migrations

  • New CLI mode kuml generate --sql-migration --from <old.kuml.kts> --to <new.kuml.kts> --version <v> --description <desc> computes the delta between two ERM model snapshots and writes a single Flyway-named migration file.
  • Only safe, additive DDL is generated (CREATE TABLE, ALTER TABLE … ADD COLUMN, CREATE INDEX, CREATE VIEW, ALTER TABLE … ADD CONSTRAINT … CHECK).
  • Any destructive or ambiguous change (dropped/renamed entities or columns, type or primary-key changes, etc.) causes generation to refuse with the complete list of blockers reported at once.
  • The new ErmSchemaDiffEmitter reuses ErmSqlEmitter’s existing per-element DDL fragment renderers rather than duplicating identifier-safety or rendering logic.
v0.29.x1 release
v0.29.02026-07-10

Language Server, interactive OCL guard editing, web drag-and-drop + ERM rendering

A new `kuml-language-server` module brings editor-agnostic LSP diagnostics and full 38-item DSL completion to any LSP-capable editor, with the VS Code extension gaining an LSP client and a live-preview webview. State-machine transition guards can now be edited interactively — a new `OclGuardEditor` Compose widget with live syntax highlighting, a `protected`-transition confirmation gate, and runtime patching (`ModelPatch.ChangeGuard`) that type-checks and applies a new OCL guard to a running state-machine instance without in-place mutation. The web editor (`kuml-web`) gained drag-and-drop node placement for class diagrams and now renders ERM diagrams end-to-end in all four notations (Martin, Bachman, Chen, IDEF1X). Also fixes ERM self-loop relationship-name/role label collisions across all three ERM notations.

Added — kuml-language-server: editor-agnostic LSP server

  • New LSP4J-based Language Server module: real-time diagnostics via CLI subprocess (with correct document ranges) and the full 38-item DSL completion catalogue, mapped to per-group CompletionItemKinds with snippet-style insert text.
  • Editor-agnostic completion/rename/diagnostics logic extracted from kuml-jetbrains-plugin into a new pure-Kotlin kuml-lang-support module, shared by both the JetBrains plugin and the LSP server.

Added — VS Code: LSP client + live-preview webview

  • The extension now locates and launches the kUML language server via an LSP client, and adds a live-preview webview panel with sanitized SVG rendering.

Added — Interactive OCL guard editing

  • OclSyntax facade for editor tooling (syntax highlight, live type-check) with a recursion-depth guard against pathological input.
  • Transitions can be marked protected; a new EditPolicy.guardEditGate always demands confirmation before a guard edit on a protected transition.
  • ModelPatch.ChangeGuard + applyPatch let a transition’s OCL guard be edited on a running state-machine instance — statically type-checked, confirmation-gated, and applied by atomically rebuilding a fresh instance.
  • OclGuardEditor — a new Compose Multiplatform text field with live OCL syntax highlighting, wired into the BehaviourWidget.

Added — kuml-web: drag-and-drop node placement + ERM rendering

  • Class-diagram nodes can be dragged to a new grid position in the web preview pane; the drop is persisted back into the DSL script via a new /api/layout/hint endpoint.
  • ERM diagrams (ExtractedDiagram.Erm) now render end-to-end through the web pipeline in all four notations, replacing the previous “not yet supported” stub.

Fixed — ERM self-loop relationship-name/role label collisions

  • Self-referential ERM relationships no longer have their name label straddle the entity border with both role labels converging on it, across all three ERM notations (Martin, Bachman, IDEF1X).
v0.28.x1 release
v0.28.02026-07-09

Security: resource bounds for the execution-free DSL interpreter

The execution-free DSL interpreter in `kuml-core-script` never compiles or runs bytecode, so it carries no RCE risk — but without bounds a pathological input could still hurt the host process: memory exhaustion during lexing, a `StackOverflowError` escaping the recursive-descent parser, or CPU burn on a huge flat input. It now enforces four resource bounds — input-size cap, parse recursion-depth guard, wall-clock timeout, and `StackOverflowError` containment — configured via the new `InterpreterLimits` type (100,000 chars / depth 64 / 5s by default) and applied through a new backward-compatible `evaluate(source, fileName, limits)` overload. Also fixes BPMN Choreography edge routing/label placement and adds background contrast to edge stereotype labels.

Security — resource bounds (DoS guards) for the execution-free DSL interpreter

  • Four bounds now enforced: an input-size cap, a parse recursion-depth guard, a wall-clock timeout, and StackOverflowError containment.
  • New InterpreterLimits value type carries the configuration (defaults: 100,000 chars / depth 64 / 5s).
  • New evaluate(source, fileName, limits) overload; the existing evaluate(source, fileName) signature is unchanged and now delegates to InterpreterLimits.DEFAULT — no breaking change for existing callers.
  • Over-limit input is rejected cheaply as an EvaluatedScript.Failure — no exception escapes the evaluator.

Fixed — BPMN Choreography: branch edges crossed intervening tasks, labels slid under the target box

  • ChoreographyGridLayout.routeFlow produced its vertical jog at the horizontal midpoint regardless of intervening nodes, so a gateway spine-branch skipping a cross-lane task ran straight through that task’s box. Routing is now obstacle-aware: when the default route would cut through another node’s bounds, the jog moves into the clear gap right after the source instead.
  • BpmnChoreoSvg’s sequence-flow condition/name label was anchored at the array midpoint with only a small fixed offset, so labels slid under the target task. It now uses the same longest-segment, haloed label placement (EdgeLabelGeometry.midAnchor + renderEdgeLabelWithHalo) already used by message flows and C4/UML edges.

Fixed — edge stereotype labels rendered without background contrast

  • StereotypeHelper.renderEdgeStereotype() emitted stereotype text (e.g. «FK») without a background halo, so the edge polyline underneath visually cut through the italic glyphs — most visible on short vertical edges.
  • Edge role/name labels already used a two-pass halo technique; renderEdgeStereotype now does the same via a new kuml-stereotype-halo CSS class. In-box header/feature stereotypes are unaffected — they never sit on a line.
v0.27.x1 release
v0.27.02026-07-09

New: ERM — Entity-Relationship Modelling as a seventh first-class metamodel

A dedicated Entity-Relationship metamodel with four production-ready notations (Martin/Crow's Foot, Bachman, Chen, IDEF1X), a UML → ERM transformation, and a `kuml-gen-sql` rearchitecture so SQL DDL — and now Kotlin Exposed code — is generated from a typed, inspectable model instead of UML stereotype matching. Also ships SQL → ERM reverse engineering, stereotypes on UML attributes and associations, and an experimental Open-Knowledge-Format workspace CLI.

ERM as a seventh first-class metamodel

New standalone module kuml-metamodel-erm: Entity/Attribute/Relationship/View/Index/CheckConstraint, plus a notation-aware ermModel { } DSL. 19 structural validation rules, wired into kuml validate.

Four notations, one model

Martin/Crow’s Foot, Bachman, Chen, and IDEF1X are all rendered from the same ermModel, selected via notation = MARTIN in the DSL or kuml render --notation <name> on the CLI.

UML → ERM → SQL / Exposed

kuml-transform-uml-to-erm derives an ERM model from an existing UML class diagram (with an ErmMappingProfile for inheritance-strategy and naming overrides). kuml-gen-sql now runs on the typed ERM model instead of matching on UML stereotype strings — composite primary keys, indexes, views, check constraints, and real many-to-many junction tables all fall out of the same emitter. The Kotlin Exposed generator was rearchitected onto the same ERM path (erm-to-exposed, uml-to-exposed-via-erm); the older stereotype-based transformers are deprecated but remain fully functional.

SQL → ERM reverse engineering

New module kuml-codegen-reverse-sql parses PostgreSQL DDL and reconstructs an ermModel — tables, columns, constraints, indexes, views, and inferred relationships (including identifying/weak entities). kuml reverse <file> --format sql prints the recovered model as DSL source.

DSL stereotypes on attributes and associations

Cosmetic «Stereotype» labels — previously class-only — now work on attributes and associations too, rendered in SVG output and accounted for in layout sizing.

Experimental: kuml workspace (Open Knowledge Format)

A small CLI spike (info / validate / render) for treating an Obsidian-vault-style directory of Markdown notes with embedded kuml code blocks as an agent-readable Open Knowledge Format workspace.

v0.26.x1 release
v0.26.02026-07-07

New: MDA persistence pipeline — UML → Kotlin Exposed ORM + Flyway baseline

A full model-driven-architecture path from a UML class diagram to a runnable Kotlin Exposed persistence layer, built for the Pepela Portal / Lapis Cloud stack (Kotlin + Exposed ORM + PostgreSQL + Flyway). Delivered as three additive pieces: a direct `uml-to-exposed` transformer emitting Kotlin Exposed `Table` objects, a renderable `uml-to-exposed-psm` variant backed by a new Exposed UML profile (`«Table»`, `«Column»`, `«FK»`), and a Flyway baseline generator that reuses the existing SQL DDL generator to write `V1__init.sql`.

uml-to-exposed — direct M2M transformer

  • New module kuml-codegen-m2m-exposed with UmlToExposedTransformer, analogous to the existing uml-to-jpa transformer.
  • Emits one Kotlin Exposed Table object per UmlClass: object Users : Table("users") { val id = long("id").autoIncrement(); ...; override val primaryKey = PrimaryKey(id) }.
  • Many-to-one associations become reference() foreign-key columns.
  • Many-to-many/collection sides and self-referential associations are intentionally skipped with an explanatory comment rather than emitting non-compiling code.

uml-to-exposed-psm — renderable PSM via a new Exposed profile

  • New profile module kuml-profile-exposed (extends the existing JavaEE profile) defining «Table», «Column», and «FK» stereotypes.
  • UmlToExposedPsmTransformer turns a raw platform-independent model into a real, diagram-renderable UML model — embeddable in Asciidoctor docs, not just a text-emitting black box.
  • Classes are dual-annotated («Table» for PSM semantics/rendering, «Entity» for compatibility) so the existing SQL generator keeps producing correct DDL from the PSM without any changes to it.

Flyway baseline generator

  • FlywayBaselineGenerator (id sql-flyway-baseline) in kuml-gen-sql — a thin wrapper composing the existing SqlDdlGenerator, no duplicated DDL logic.
  • Writes output as V<version>__<description>.sql (Flyway’s migration-file convention, default V1__init.sql) instead of the generic schema.sql.
  • Works unchanged against either the raw PIM or the new Exposed PSM.

Deferred to a later release: custom-type hooks for PostGIS geometry and TimescaleDB hypertables.

v0.25.x1 release
v0.25.02026-07-07

New: kuml.examples MCP tool — targeted syntax examples for any diagram type

A new `kuml.examples` MCP tool lets LLMs proactively request curated example scripts for a specific diagram type (`language` + optional `diagramType`). Called with just `language`, it returns a discovery list of available types first — supporting a natural "what can I draw → show me an example" flow. 34 new granular Resources at `kuml://dsl/examples/<language>/<diagramType>` complement the tool; the existing aggregate Resource is unchanged. Driven by GCR benchmark data: Gemini scored 0 % first-shot on C4 and showed 64–69 % hallucination rates on sequences — classic symptoms of missing syntax anchoring that a targeted few-shot example resolves.

kuml.examples — targeted few-shot examples via MCP

  • New MCP Tool (tools are invoked proactively by LLMs, unlike resources) accepting language (uml | c4 | sysml2 | bpmn | blueprint) and an optional diagramType.
  • Returns the matching curated example script(s) as raw ```kuml blocks with a one-sentence description and the source note reference.
  • Called with only language → returns a discovery list of available diagram types for that language (“what can I draw?”).
  • Invalid parameters produce structured KUML-MCP-E-EXAMPLES-* error codes with the list of valid values.

Granular per-type Resources

  • 34 new Resources at kuml://dsl/examples/<language>/<diagramType>, all fed from the same ExampleCatalog.
  • The existing aggregate Resource kuml://dsl/examples is unchanged — fully backward-compatible.

ExampleCatalog

  • Hand-curated mapping of 38 of the 42 bundled Vault examples (4 excluded: index note + 3 SMIL animation variants).
  • Classified by DSL entry point, not by note title. journey is a diagramType under blueprint, not a separate language.
  • A completeness test enforces a catalog decision for every newly synced example, preventing silent gaps.
v0.24.x4 releases
v0.24.62026-07-05

kuml-mcp never connected from Claude Code — every response failed strict client-side validation

kuml-mcp's JSON encoder was configured with `encodeDefaults = true` but without `explicitNulls = false`, so every response serialized both `result` and `error` — the unused field as a literal `null` (e.g. `{"jsonrpc":"2.0","id":1,"result":{...},"error":null}`). Strict MCP clients such as Claude Code validate responses against a JSON-RPC 2.0 union schema that rejects a `result`/`error` pair appearing together at all, even when one side is `null` — every otherwise-correct kuml-mcp response failed that validation, and the client reported the connection itself as broken, with no indication that the payload shape was the cause. Fixed by adding `explicitNulls = false` to the encoder so only the field that's actually set gets serialized.

Critical — kuml-mcp never connected from Claude Code

  • Every JSON-RPC response carried both result and error: null at once — a serialization bug caused by encodeDefaults = true without explicitNulls = false.
  • Strict MCP clients reject that response shape outright and report the connection itself as failed, not the individual call — which hid the real cause from the outside.
  • Fix: explicitNulls = false in the JSON encoder, plus a new regression test asserting the two fields never appear together.
  • Verified with a full manual JSON-RPC handshake (initialize / tools/list / tools/call / an unknown method name) and a real claude mcp list connection, which now reports ✔ Connected in ~4.5s instead of timing out.
v0.24.52026-07-05

Chocolatey uninstall fixed on Windows + test isolation for the plugin directory

During the first real elevated `choco uninstall kuml-desktop` on Windows, the uninstall script failed immediately with a PowerShell parse error before running any of its logic. Root cause: a UTF-8 em-dash inside an active `Write-Warning` string, but the file had no UTF-8 BOM — Windows PowerShell 5.1 reads BOM-less .ps1 files using the system's ANSI codepage rather than UTF-8, so those bytes decoded as unexpected characters and broke the tokenizer for the whole script. Also: the test suite was silently writing into the real `~/.kuml/plugins` directory on repeated local test runs, since — unlike `KumlHome.base()` — no test override existed for it.

Chocolatey: chocolateyUninstall.ps1 could not be parsed at all

  • A UTF-8 em-dash inside a Write-Warning string, in a file with no UTF-8 BOM, made PowerShell 5.1 read the bytes via the system’s ANSI codepage — breaking the tokenizer for the entire script regardless of which branch would actually have run.
  • Fix: replaced the em-dash with a plain hyphen and added a UTF-8 BOM to all four Chocolatey install/uninstall scripts as defense-in-depth.
  • Verified with [System.Management.Automation.Language.Parser]::ParseFile (0 syntax errors) and a real elevated choco uninstall kuml-desktop round-trip.

Test suite: missing test seam for the plugin directory

  • PluginInstallCommand, PluginRemoveCommand, and PluginUpgradeCommand all read/wrote PluginScanPath.userPluginDir directly with no way to redirect it in tests — so repeated local test runs accumulated fixture jars in the real ~/.kuml/plugins, later breaking unrelated tests with ClassNotFoundException.
  • Fix: added the same test-seam pattern already used by KumlHome (overrideUserPluginDirForTest / clearTestOverride, backed by a kuml.plugins.dir system property) to the three affected commands. Test-only change; no production behaviour affected.
v0.24.42026-07-05

Critical Windows fix: kuml.bat could not start on any Windows install

The first release verified end-to-end against a real Windows 11 host. No Windows machine had ever actually run `kuml.bat` before — and it showed: the Gradle-generated classpath line lists all ~300 bundled jars on a single ~14.9 KB line, and cmd.exe refuses to read any line over ~8191 characters. kuml.bat failed on every invocation on every Windows install to date, whether via Chocolatey or a direct zip download, before ever reaching java.exe. Fixed with a "pathing jar" (the standard technique used by maven-jar-plugin/sbt-native-packager): a stub jar whose manifest Class-Path attribute lists every real jar, so the command line itself stays short. Also: the Windows Job Object sandbox for kuml-mcp is now hardware-verified (previously construction-verified only), and the kuml-desktop Windows MSI is confirmed to build on real Windows for the first time.

Critical — kuml.bat could not start at all

  • The generated set CLASSPATH=... line (~300 jars: AI providers, Compose Multiplatform, the AWS Bedrock SDK, the Kotlin compiler-embeddable, ELK, Batik, Ktor, …) is ~14.9 KB long — cmd.exe refuses any line over ~8191 characters, whether as source text or after variable expansion.
  • Fix: a “pathing jar” — a stub jar with no classes, just a manifest Class-Path attribute listing every real jar as a relative filename. The command line then only ever needs a single short path.
  • Applied unconditionally to both kuml.bat and kuml-mcp.bat — the actual failure threshold depends on install path depth, not jar count, which was reproduced on the smaller kuml-mcp.bat at a deep test path.
  • Verified without a system JDK: kuml --version, kuml --help, kuml ai --help, a full kuml render (Kotlin scripting compiler, ELK layout, Batik SVG), and a real choco install kuml.

Windows sandbox now hardware-verified

  • The Windows Job Object sandbox for kuml-mcp, introduced in v0.23.3, was construction-verified only until now — 8 new behavioural tests now run against a real Windows kernel (Job Object creation, memory cap, process-spawn blocking, kill-on-close, fail-closed/best-effort degradation).
  • kuml-desktop’s Windows MSI (packageMsi) is confirmed to build successfully on real Windows for the first time; structure (bundled JRE, correct classpath) validated via administrative MSI extraction.
v0.24.02026-07-05

Apple Signing & Notarization, MCP Sandbox Overhaul, MP4 Export, Full WASM Playground

v0.24.0 bundles 23 previously-unreleased commits into one distribution-quality release. The headline is real Apple Developer ID code signing + notarization for the macOS `kuml-desktop` DMG and the bundled Java runtime shipped with the `kuml` / `kuml-mcp` command-line tools — which fixes a previously-reported bug where `kuml-mcp` refused to start as a child process of a hardened parent app (e.g. Claude Desktop) because macOS's AMFI/Library Validation rejected the ad-hoc-signed native libraries inside the runtime. Everything is now signed under the hardened runtime with a proper Developer ID and notarized by Apple (verified end-to-end in the v0.24.0 release build — Apple returned "Accepted" for both the DMG and the runtime bundle). Alongside that: a nine-layer defence-in-depth overhaul of the MCP script-evaluation sandbox, MP4 export for animated diagrams, a WASM Playground that now renders C4, SysML 2, BPMN and Blueprint entirely client-side, Chocolatey packaging for Windows, and live-rendered C4/BPMN/SysML 2 diagrams plus a theme gallery in the handbook.

macOS Distribution — Apple Developer ID Signing + Notarization

  • The kuml-desktop DMG and the bundled Java runtime inside the kuml / kuml-mcp command-line tools are now signed with a proper Apple Developer ID under the hardened runtime and notarized by Apple — verified end-to-end in the actual v0.24.0 GitHub release build, where Apple’s notarization service returned “Accepted” for both the DMG and the runtime bundle.
  • Fixes a real, previously-reported bug: kuml-mcp refused to start when launched as a child process of a hardened parent app (e.g. Claude Desktop), because macOS’s security system (AMFI / Library Validation) rejected the ad-hoc-signed native libraries inside the bundled runtime. With proper Developer ID signing the child process now launches cleanly.
  • Practical user-facing win: brew install --cask kuml-desktop and brew install kuml (which now ships a working kuml-mcp) no longer trigger Gatekeeper’s “unidentified developer” block, and the MCP server works out of the box from Claude Desktop.

MCP Sandbox — Nine-Layer Defence-in-Depth Overhaul

  • Before this release, kuml-mcp evaluated untrusted scripts in-process with no isolation beyond a regex denylist (KumlScriptGuard) — which itself had a reflection-based bypass hole, now closed.
  • Script evaluation now runs in an isolated child process backed by a warm worker pool, cutting per-call overhead from a ~1.6 s cold start to a ~280 ms warm hit.
  • OS-native sandboxing on macOS (sandbox-exec) and Linux (bwrap) — both hardware-verified; on Linux the audit found and fixed a real gap where ~/.ssh was readable from inside the sandbox.
  • Windows uses a Job Object with graceful best-effort degradation — hardware-verified on real Windows 11 as of v0.24.4 (Job Object creation, memory cap, process-spawn blocking, kill-on-close).
  • A restricted ClassLoader plus a curated classpath add a further defence-in-depth layer regardless of OS.
  • An experimental Data-DSL interpreter option compiles the DSL through a real parser instead of the Kotlin compiler, so it structurally cannot execute arbitrary code — currently limited to UML class diagrams only.

MP4 Export + Full WASM Playground

  • New MP4 export (ffmpeg H.264) for animated diagrams, joining the existing APNG and WebP animated-export options.
  • The WASM Playground now renders C4, all 8 SysML 2 diagram types, all 4 BPMN diagram types, and Blueprint diagrams entirely client-side in the browser — previously only UML class diagrams were wired into the WASM renderer.
  • The Playground gained a real multi-column grid layout, replacing the single-row demo placeholder.
  • Two real export bugs fixed along the way: a non-English-locale decimal-comma bug that broke ffmpeg’s framerate argument, and an odd-pixel-dimension bug that broke H.264 encoding.

Windows Packaging + Handbook

  • Chocolatey packaging for Windows: kuml-mcp now ships a self-contained launcher bundled for Chocolatey (no system JDK required), and kuml-desktop is published as its own separate Chocolatey package.
  • The handbook now embeds live-rendered C4, BPMN, and SysML 2 diagrams inline (previously only UML and Blueprint diagrams rendered inline).
  • New handbook theme gallery showing the same diagram rendered across all four built-in themes.
  • A FUNDING.yml was added, plus a broad round of stale-fact fixes across the module READMEs.
v0.23.x3 releases
v0.23.22026-07-03

UML Edge Label Halo — Association Role Names and Dependency Labels Now Always Readable

A targeted renderer fix: role names on association ends (`role = "orders"`, `role = "items"`), multiplicity labels (`0..*`, `1..*`), and mid-edge dependency/connector names (`"notifies"`, `«include»`, `«extend»`) now emit a two-pass halo element before the visible text, identical to the technique already used for C4 and BPMN edges. Previously the edge polyline stroke bled through the text glyph when a line crossed or ran directly through the label — most visible in the Order Domain class diagram. Batik-safe (no `paint-order` reliance); works in Obsidian, kuml.dev playground, and PNG export.

Fixed

  • renderEdgeLabel (association names, dependency names, «include»/«extend» labels) now delegates to renderEdgeLabelWithHalo, emitting the kuml-edge-label-halo background pass before the visible text — identical to what C4 and BPMN already did.
  • endpointLabel (multiplicity and role name labels at association ends) now emits a kuml-small-halo background element first. A matching CSS class is added to SvgDocument.buildDefs.
  • renderUmlLink source/target role labels refactored to use endpointLabel, eliminating inline duplication and picking up the halo for free.
v0.23.12026-07-03

UML Comment / Note Element

v0.23.1 adds `UmlComment` — the classic UML note box with a folded top-right corner, optionally attached to one or more model elements by a dashed `UmlCommentLink` line. Available via `comment(text = ..., firstAnchor = ...)` on class, sequence, and state-machine diagram bodies. Comment text goes through the existing XML-escaping path, pinned by dedicated XSS regression tests — safe for embedding in browsers and Obsidian previews.

Added — UML Comment / Note

  • comment(text, firstAnchor?, moreAnchors?, anchors?) DSL function on class, sequence, and state-machine diagram scopes. Renders as a free-text box with a folded top-right corner and a dashed attachment line to each anchor.
  • Free-standing notes (no anchors) are supported — useful for diagram-level TODO annotations or legend boxes.
  • Multiple anchors via moreAnchors = arrayOf(...) or by raw string ID via anchors = arrayOf("Order", "Subscription").
  • Other diagram types (BPMN, SysML 2, C4, component, use case, activity, …) do not have comment() yet — documented as an intentional scope limitation, not an oversight.

Fixed

  • Website: v0.23.0 What’s New entry and Playground SVGs were stale after the release — added the missing entry and re-rendered all Playground examples.
v0.23.02026-07-02

OCL Goes Full 2.4/2.5, MCP Resources, kuml-mcp Bundled in Homebrew, Desktop Cask

v0.23.0's headline: `kuml-core-ocl` implements the full OCL 2.4/2.5 expression language instead of a basic-constraints subset — collection iterators (`select`/`reject`/`collect`/`iterate`/…), `let`/`if` expressions, Real arithmetic, association-end and opposite navigation with a metamodel-driven accessor (no reflection, still Native-Image/KMP-safe), `closure()`, type operations (`oclIsTypeOf`/`oclIsKindOf`/`oclAsType`), and `def:`/`pre:`/`post:`/`body:` constraint stereotypes — plus OCL validation now covers BPMN and SysML 2 models, not just UML, with real source positions in error output. `kuml-mcp` also gets a Resources capability (`kuml://dsl/reference`, `/examples`, `/schema`) so MCP clients auto-load kUML's DSL knowledge instead of only learning it through render/compile-error iteration. On the distribution side, `brew install kuml` now ships the MCP server binary, and `kuml-desktop` gets its own Homebrew Cask.

OCL: Full 2.4/2.5 Expression Language

  • Collection iterators (select/reject/collect/iterate/any/one/sortedBy/isUnique/sum/count/including/excluding/union/intersection/first/last/asSet/asSequence), let/in and if/then/else/endif expressions, and Real arithmetic with correct Int/Real promotion.
  • Association-end navigation (including opposite ends and multi-step chains) via a metamodel-driven property accessor — no kotlin-reflect, so it stays Native-Image and Kotlin Multiplatform safe. closure() walks the association graph cycle-safely.
  • Type operations (oclIsTypeOf/oclIsKindOf/oclAsType/oclIsUndefined/oclIsInvalid) against the classifier and generalization hierarchy, plus def:/pre:/post:/body: constraint-kind stereotypes with result and @pre snapshot support.
  • OCL constraint validation now covers BPMN and SysML 2 models, not just UML. kuml validate --output json (alias --format) includes source positions (line/column) for every violation.
  • A new conformance test suite exercises OMG OCL §7.4–7.6 examples plus a completed String/Integer/Real standard-library surface, with an honest coverage matrix — the docs are explicit about what remains deliberately unsupported (Tuple types, oclType() reflection, collection literals, real operation-body execution, no formal OMG certification).

MCP Resources — a Lehrkanal, not just a feedback loop

  • kuml-mcp now advertises capabilities.resources and serves three resources: kuml://dsl/reference (bundled handbook DSL reference), kuml://dsl/examples (curated vault example scripts), and kuml://dsl/schema (machine-readable builder-signature schema).
  • resources/list and resources/read are wired analogously to the existing tools/list/tools/call handlers, so MCP clients (Claude Desktop, Cursor, …) can load kUML’s DSL knowledge automatically instead of only learning it through render/compile-error iteration.

Distribution: MCP Server in Homebrew, Desktop Cask

  • The standalone kuml-mcp binary is now bundled into the shared runtimeZip artifact, so brew install kuml (and SDKMan!) ships a working MCP server out of the box.
  • kuml-desktop gets its own Homebrew Cask (brew install --cask kuml-desktop) — this required adding the first-ever kuml-desktop DMG build+upload job to the release workflow.

Handbook & Documentation

  • Handbook pages now embed live-rendered [kuml] diagrams via a new kuml asciidoc CLI bridge (Antora runs on Asciidoctor.js, which can’t load the JVM-based kuml-asciidoc extension directly — the bridge pre-renders [source,kuml] blocks to SVG before Antora consumes the tree).
  • MCP documentation corrections: no more references to a nonexistent kuml.diagram.* tool prefix or a nonexistent kuml ai mcp-stdio command; parameter names in the Behaviour-Runtime handbook page now match the real tool schemas; a new authoring-mcp.adoc page documents all 5 authoring tools.
  • Fixed a Maven Central release-workflow guard that only checked one of three Kotlin Multiplatform publication legs before deciding to skip a re-run — a partial publish failure could have silently orphaned the missing legs on an immutable version.
v0.22.x1 release
v0.22.02026-07-01

Animated APNG/WebP Export, Choreography Grid Layout, Full Kotlin Multiplatform & WASM Playground

v0.22.0 makes SMIL animation exportable outside the browser: `kuml render --animated -f apng` / `-f webp` produces a real animated raster file, no browser required. BPMN Choreography diagrams get a dedicated grid layout (replacing the generic ELK-based BPMN layout) plus new constraint checks. The Kotlin Multiplatform migration goes all the way through the renderer core — `kuml-io-svg` and its dependency chain now target jvm/js/wasmJs. And the kuml.dev Playground gets an experimental client-side WASM rendering toggle: diagrams rendered entirely in the browser, no CLI round-trip.

Animated APNG / WebP Export

  • New kuml-io-anim module: kuml render --animated -f apng or -f webp renders SMIL-animated diagrams to a real animated raster file.
  • Frame extraction via a Batik clock-freeze pipeline, with a dependency-free fallback sampler — including fixes for a namespace-reprefixing bug and a German-locale float-formatting bug that both silently produced broken frames, plus correct SMIL “sandwich” resolution so overlapping animation cycles no longer cancel each other out.
  • DoS guards (500 frames / 30s / 50MB) and JetBrains export-dropdown integration (WebP greyed out when ffmpeg is missing).

BPMN Choreography — Grid Layout & Constraint Checks

  • A dedicated grid layout algorithm now positions choreography diagrams instead of reusing the generic ELK-based BPMN layout — topological ranking, per-column lane assignment, loop back-edges routed below all lanes.
  • New BpmnConstraintChecker rules for choreography diagrams (dangling flow references, unreachable elements, gateway condition mismatches, participant-band continuity).
  • Fixed a layout bug where message-envelope glyphs on adjacent choreography tasks could visually collide with neighboring lanes.

Kotlin Multiplatform — Full Renderer Core (jvm/js/wasmJs)

  • kuml-io-svg and its full dependency chain (kuml-layout-api, kuml-layout-bridge, kuml-themes-core, kuml-metamodel-sysml2, kuml-metamodel-bpmn, kuml-metamodel-blueprint, and more) now target jvm/js/wasmJs, alongside the core DSL modules migrated in the previous release.
  • Maven Central publishing extended to multi-target coordinates (-jvm/-js/-wasm-js) for all migrated modules.

kuml.dev Playground — Experimental Client-Side WASM Rendering

  • KumlDiagram is now JSON-serializable; a new kuml-wasm-playground module renders SVG entirely in Kotlin/Wasm — no JVM, no CLI round-trip.
  • The Playground gained a “Render via WASM (experimental)” toggle on the UML class-diagram example, swapping the pre-rendered SVG for a live client-side render.
  • Scope is UML-only for now — other notations aren’t wired into the wasm renderer yet.
v0.21.x1 release
v0.21.02026-06-30

BPMN 2.0 Choreography + Conversation, Sequence Animation & JetBrains Export

v0.21.0 is the biggest BPMN release yet: it adds two whole new BPMN 2.0 sub-notations — Choreography diagrams (double-bordered tasks with initiator/responder participant bands) and Conversation diagrams (hexagon nodes with message links) — fully wired from DSL to CLI. UML sequence diagrams now animate, with message dots gliding along the arrows under `kuml render --animated`. The JetBrains plugin grows up: a theme combobox in the preview toolbar and one-click SVG / PNG / TeX export.

BPMN 2.0 Choreography Diagrams

  • New ChoreographyTask, ChoreographyGateway, and ChoreographyEvent nodes connected by MessageFlow and ChoreographySequenceFlow.
  • The renderer draws the characteristic double border on choreography tasks and pins participant bands per the BPMN spec — initiator on top, responder on the bottom.
  • Reachable from the CLI with a ready-made vault example (37 BPMN Choreography – Bestellprozess).

BPMN 2.0 Conversation Diagrams

  • New ConversationNode, ConversationLink, and CallConversation model elements.
  • Conversation nodes render as hexagons, matching the BPMN 2.0 notation.
  • Shipped with the 36 BPMN Conversation – PdV Kommunikation vault example and render smoke tests.

Animated UML Sequence Diagrams

  • kuml render --animated now animates sequence diagrams — messages travel as dots along the message arrows via SMIL animateMotion.
  • Built on a new trace model (MessageSent / MessageReceived) plus a timeline builder and dedicated SMIL renderer, with a DoS-guard and injection tests.
  • New vault example: 19 UML Sequence animiert – API Submit.

JetBrains Plugin — Themes & Export

  • A theme combobox (kuml, plain, elegant, playful) right in the preview toolbar, with your choice persisted across sessions (default kuml).
  • A new export dropdown for SVG, PNG, and TeX — auto-saves the rendered output via a background CLI call and confirms with a balloon notification.
v0.20.x6 releases
v0.20.52026-06-29

kuml Is Now the Default Theme + Cross-Notation Label Polish

v0.20.5 makes the full-featured `kuml` house theme the default everywhere — render without a `--theme` flag and you now get brand colours, blue accents, and the Inter font instead of the minimal grayscale `plain` theme. It also polishes label placement across BPMN, C4, and UML/SysML state machines so labels no longer collide with edges, nodes, or the canvas border.

kuml Theme Is Now the Default

  • Rendering without an explicit --theme flag or kuml.config.kts now uses the kuml house theme (brand colours, blue accents, Inter font) instead of plain — across the CLI, Web/Server pipeline (Obsidian auto mode), the Gradle plugin, and the Desktop app.
  • BPMN renderers now honour the active theme as well; previously every BPMN diagram rendered in hardcoded black-and-white regardless of the selected theme, looking inconsistent next to UML.
  • Pass --theme plain (or theme.set("plain")) to restore the old grayscale look.

Label Placement Polish Across Notations

  • BPMN MessageFlow labels (e.g. “Purchase Order” in a two-pool collaboration) no longer collide with the dashed edge — they are placed on the longest segment of the route with a perpendicular offset and a background halo.
  • BPMN event/gateway labels near the canvas edge are no longer covered by ELK-routed edges — layout bounds now reserve space for the below-shape labels.
  • UML/SysML state-machine back-edge labels (e.g. Yellow→Red in a traffic-light STM) no longer overlap intermediate states or overflow the diagram frame.
  • C4 Component and Container diagrams now render the boundary label (name + stereotype) in the reserved top inset of the boundary box.
v0.20.42026-06-29

BPMN Animation Overhaul + AUTOSAR Classic Example

v0.20.4 is a comprehensive overhaul of BPMN animated rendering: type-specific node highlighting for tasks and events, gateway highlights with automatic reset, infinite looping, and corrected SVG ID-targeting so fill animations actually recolour the shapes. It also adds a new AUTOSAR Classic SW-component example.

BPMN Animation v3.1.33

  • Type-specific node highlighting: tasks pulse light-blue (#e3f2fd), start events light-green, end events light-red, gateways amber with automatic reset.
  • Infinite looping by default (practical cap ≈ 23 minutes of playback at 1× speed).
  • Critical SVG ID-targeting fixes: task rectangles and event circles now carry unique IDs so fill animations recolour the actual shapes instead of being blocked by child fill attributes.

New Example — AUTOSAR Classic SW-Components

  • New vault example 35 (AUTOSAR Classic SW-Komponenten) with a staircase grid layout that avoids U-routes through component boxes and frame clipping.
v0.20.32026-06-29

BPMN Edge Routing Fix — No More Frame-Piercing + Label Clipping

v0.20.3 fixes two visual rendering bugs in BPMN Process diagrams: outer SequenceFlow edges that connect to an expanded SubProcess now dock cleanly to the frame border instead of routing through its interior, and event/gateway labels near the canvas edge are no longer clipped.

BPMN — Outer Edge No Longer Pierces SubProcess Frame

  • SequenceFlow edges between top-level tasks and an expanded SubProcess now connect correctly to the SubProcess frame border — previously they were routed straight through the interior of the frame.
  • Root cause: the layout bridge was placing a 0×0 phantom node inside the SubProcess’s ELK compound group as an edge anchor, causing ELK to route the edge to an interior coordinate. The phantom node is now removed; outer edges resolve to the compound group boundary via the same ELK groupMap fallback used for C4 container boundaries.
  • No DSL changes required — all BPMN diagrams with expanded SubProcesses benefit automatically.

BPMN — Event/Gateway Labels and SubProcess Names Fully Visible

  • Event and gateway labels (rendered below the node, outside the node bounds) no longer get clipped by the SVG viewBox when they appear near the bottom or sides of the diagram.
  • Fix: renderBpmnProcess now estimates the per-side label overflow and inflates the canvas accordingly before rendering.
  • Expanded SubProcess names are now placed at the top of the frame (BPMN convention) rather than vertically centred — previously the centred name collided with child flow-nodes.
v0.20.22026-06-28

BPMN Animated Trace Now Wired in CLI

v0.20.2 wires `BpmnSmilRenderer` into the CLI render pipeline: `kuml render --animated --trace <file>` now produces animated BPMN SVGs. Previously the renderer was implemented and tested but never called from the CLI path.

BPMN Animation — kuml render --animated --trace Now Works

  • kuml render --animated --trace <trace.json> now produces animated BPMN process SVGs with highlighted tokens, active tasks, and gateway decisions.
  • RenderPipeline.renderBpmn() now accepts animated, traceFile, and speed parameters and delegates to BpmnSmilRenderer when a trace file is supplied.
  • Without --trace, --animated for BPMN prints a clear warning and falls back to static SVG — BPMN does not synthesise a demo trace automatically (unlike STM/Activity diagrams).
v0.20.12026-06-28

SMIL Browser Compatibility Fix — Chrome & Safari

v0.20.1 is a targeted bugfix: animated SVGs generated by `kuml render --animated` now play back correctly in Chrome and Safari in addition to Firefox. The fix is in SmilEmitter — `href` attributes are written as `xlink:href` and the `xmlns:xlink` namespace is injected into the root `<svg>` element.

SMIL Animation — Browser Compatibility Fix

  • Chrome and Safari now play animated SVGs correctly. Previously kuml render --animated produced SVGs that animated in Firefox but were silently ignored by Chrome and Safari — because both require the legacy xlink:href attribute on <animate> / <animateTransform> elements, not the modern href.
  • Fix in SmilEmitter: all href attributes are now written as xlink:href, and xmlns:xlink="http://www.w3.org/1999/xlink" is injected into the root <svg> element automatically.
  • No DSL changes required — existing .kuml.kts scripts that use --animated produce cross-browser SVGs after upgrading to v0.20.1.
v0.20.02026-06-26

SMIL Animation, AUTOSAR/ARXML, C++/C#, EMF Profile, chain-evm CLI, BPMN⇌UML Bridge

v0.20.0 ships six major feature areas: animated SVG diagrams driven by execution traces (SMIL), full AUTOSAR Classic and Adaptive ARXML import/export, C++ and C# codegen and reverse-engineering plugins, round-trip conversion between kUML profiles and Eclipse UML2 .profile.uml, live EVM smart-contract event subscriptions via `kuml chain events`, and a bidirectional BPMN⇌UML Activity M2M bridge (`kuml transform --transformer bpmn-to-uml-activity` and `uml-activity-to-bpmn`).

SMIL Animation — Animated SVG from Execution Traces

  • New kuml-io-svg-animate module: post-processes any rendered SVG with SMIL <animate> and <animateTransform> elements driven by a recorded execution trace.
  • kuml render --format svg-animate --trace <trace.json> produces a self-contained animated SVG — no JavaScript, no external runtime required. Plays back state-machine transitions and activity token flows at configurable speed.
  • Highlight rings around active vertices animate opacity and stroke-color in sync with the trace timeline. Edge highlights travel along the routed path for token/message flows.
  • Supports UML State Machine, SysML 2 STM, SysML 2 ACT, and BPMN process diagrams. Two playground examples added: animated BPMN PdV Mitgliedsantrag and animated Traffic Light STM.

AUTOSAR Classic & Adaptive — ARXML Import/Export

  • New kuml-io-autosar module: reads and writes AUTOSAR ARXML (Classic Platform R22-11 and Adaptive Platform R23-03) via an XXE-hardened DOM parser — no AUTOSAR tool licence required.
  • kuml import --format arxml parses SoftwareComponent, ComInterface, Port, Runnable, InternalBehavior, and BehaviorSpec elements into the existing autosarProfile stereotype hierarchy.
  • kuml export --format arxml serialises the kUML model back to valid ARXML — round-trip tested against real ECU supplier archives. Adaptive Platform PortInterface and ServiceInstance variants supported.
  • New 35 AUTOSAR Classic – SW-Komponenten vault example: a Brake-ECU with three SoftwareComponents, S/R interfaces, and port connections — included as a playground example.

C++ and C# — Codegen + Reverse Engineering

  • New kuml-gen-cpp module: generates C++17 header (.hpp) and implementation (.cpp) files from UML class diagrams. Supports inheritance, associations (smart pointers), enumerations, and const/static member modifiers.
  • New kuml-gen-csharp module: generates C# 12 (.cs) files with record, interface, enum, and XML-doc comments derived from UML notes. Nullable reference types enabled (#nullable enable).
  • New kuml-plugin-cpp-reverse plugin: parses C++ headers with a lightweight Kotlin lexer (no libclang dependency) and emits .kuml.kts class diagrams. Handles class/struct, single and multiple inheritance, #include directives as dependency edges, and template<> parameters as type parameters.
  • New kuml-plugin-csharp-reverse plugin: parses C# sources via regex-assisted PSI and emits .kuml.kts. Handles record, interface, abstract class, partial class, and LINQ-typed property types. kuml reverse <dir> --lang cpp and --lang csharp auto-route to the new engines.

EMF Profile Conversion — kUML ↔ Eclipse UML2 .profile.uml

  • Extended kuml-io-emf with bidirectional profile conversion: kuml export --format uml2-profile writes a .profile.uml file consumable by Papyrus and Eclipse Modeling Framework tooling.
  • kuml import --format uml2-profile reads an existing .profile.uml and reconstructs the kUML Profile, Stereotype, Extension, and tagged-value definitions — enabling import of third-party profiles (e.g. MARTE, EAST-ADL) without manual transcription.
  • Metaclass extensions, stereotype generalizations, and enumeration-typed tagged values are all preserved in the round-trip.

chain-evm CLI — Live EVM Event Subscriptions

  • kuml chain events --live now streams new events in real time via eth_subscribe (WebSocket) in addition to the existing eth_getLogs paginated replay mode.
  • New kuml chain watch <contract-address> [--event <signature>] convenience wrapper: connects, subscribes, and pretty-prints decoded events to stdout — useful for monitoring model-backed contracts during development.
  • EVM adapter extended with eth_call support: kuml chain read <fn-sig> [args…] reads view functions without sending a transaction — enables read-only model verification against live contract state.

BPMN⇌UML Activity M2M Bridge

  • New kuml-transform-bpmn-uml module: two-way M2M transformer between BPMN 2.0 process models and UML Activity diagrams.
  • kuml transform --transformer bpmn-to-uml-activity maps BpmnTask → OpaqueAction, BpmnGateway (exclusive) → DecisionNode/MergeNode, BpmnGateway (parallel) → ForkNode/JoinNode, start/end events → InitialNode/ActivityFinalNode, and SequenceFlow → ControlFlow.
  • kuml transform --transformer uml-activity-to-bpmn maps the reverse direction — useful for generating BPMN XML from UML-authored process models for import into Camunda or Zeebe.
  • New 10 BPMN zu UML-Aktivität – PdV Prozess vault example demonstrates the bridge with the PdV Mitgliedsantrag process.
v0.19.x1 release
v0.19.02026-06-25

JetBrains Marketplace, Scroll Pane, Outer UML Frame

v0.19.0 launches the kUML plugin on the official JetBrains Marketplace and ships a major IntelliJ UX overhaul: a scrollable SVG preview with hand-drag panning, a redesigned icon-only toolbar, a new `kuml diagnostics` command for IDE integration, and an outer UML diagram frame across all 33 diagram types.

JetBrains Marketplace — Official Listing

  • The kUML plugin is now available on the JetBrains Marketplace (dev.kuml.ide). Install via Settings → Plugins → Marketplace → search “kUML” in any IntelliJ-based IDE (IntelliJ IDEA, PyCharm, WebStorm, …).
  • Plugin signing configured with a dedicated certificate chain — all future releases are automatically signed and published via the release.yml CI pipeline on every v*.*.* tag push.
  • Supports both K1 and K2 Kotlin compiler frontends (supportsK1="true" supportsK2="true"); compatible with IntelliJ 2024.3+ (build 243).

IntelliJ Plugin — Scroll Pane & Interaction

  • SVG preview area is now embedded in a JScrollPane: horizontal and vertical scrollbars appear automatically for large diagrams — no more clipping of communication, class, or SysML diagrams.
  • Hand-drag interactor: left-click + drag pans the view (hand cursor on hover, grab cursor while dragging). Mouse wheel scrolls vertically; Ctrl+mouse wheel zooms.
  • Zoom model revised: Fit to Window / Fit Width / Fit Height / 100% / Zoom In / Zoom Out all control the canvas preferred size instead of the Batik rendering transform — fully scroll-compatible.
  • Toolbar redesign: text buttons replaced with icons; new Fit Width, Fit Height, and Zoom Out actions added.
  • Plugin icon updated: navy background (#1d2b4f) with golden {k} monogram (#c49a2e) and “kUML” lettering — path-based, no font dependency.

New CLI Command: kuml diagnostics

  • Emits script compile/eval diagnostics as TSV (severity⇥startLine⇥startCol⇥endLine⇥endCol⇥message). Always exits 0 — designed for editor integration.
  • Used by the JetBrains plugin’s External Annotator for inline error highlighting without blocking the IDE.

Renderer — Outer UML Diagram Frame

  • All 33 diagram types now render with an outer UML diagram frame: a titled rectangle following the UML notation standard. Previously the frame was absent, making diagrams look floating when embedded in documents.
v0.18.x1 release
v0.18.02026-06-24

Chain-Cosmos, Chain-Wasm, User Journey Blueprint

v0.18.0 ships three tracks: two new blockchain chain adapters for CosmWasm/Substrate (`kuml-runtime-chain-cosmos`) and ink!/SCALE (`kuml-runtime-chain-wasm`); and the first-class User Journey / Service Blueprint language with a Kotlin DSL, five-lane SVG renderer, CLI integration, constraint checker, LaTeX/TikZ output, and the PdV Mitglieder-Journey as a real-world blueprint example.

Chain Adapters — CosmWasm & ink!

  • kuml-runtime-chain-cosmos: chain adapter for CosmWasm smart-contract queries and Substrate RPC endpoints. Generates architecture diagrams from live on-chain state via contract introspection and state diffing.
  • kuml-runtime-chain-wasm: chain adapter for ink! smart contracts — parses ABI metadata and SCALE codec, decodes deployed contracts into kUML metamodel elements for automatic class and interaction diagrams.
  • Both adapters integrate with the existing MultiChainAdapter and support kuml chain connect/verify/events commands.

User Journey / Service Blueprint DSL

  • New kuml-metamodel-blueprint module: Actor, Phase, Step, Touchpoint, Emotion, and BackstageAction as first-class metamodel elements.
  • blueprint{} Kotlin builder DSL: nested phase/step/touchpoint hierarchies, emotion curves (−2 … +2), frontstage/backstage lane separation, channel declarations.
  • Two new SVG render modes: JourneyMapRenderer (swimlane layout with emotion curve overlay) and FullBlueprintRenderer (five-lane layout: Actor / Frontstage / Backstage / Support Processes / Physical Evidence).
  • kuml render --type blueprint and kuml render --type journey route to the new renderers; --svg, --png, --pdf output flags fully supported.
  • BlueprintConstraintChecker: validates well-formedness — every step belongs to a phase, touchpoints reference a declared actor, emotion values clamped to −2 … +2.
  • BlueprintTikzRenderer: emits compilable .tex with TikZ swim-lane matrices and spline emotion curve for high-quality print output (kuml render --type blueprint --format tex).
  • PdV Mitglieder-Journey example: end-to-end blueprint of the Partei der Vernunft member onboarding — Entdeckung → Interessenbekundung → Antragstellung → Beitrittsprozess → Willkommen → Erstes Engagement. Included as a kuml-vault-examples-tests smoke-test fixture and Playground example.
v0.17.x1 release
v0.17.02026-06-23

Plugin SPI, AI-Assistent, State Machine & Deployment

v0.17.0 ships three interleaved tracks: a Plugin SPI with `kuml plugin init` scaffolding, update commands, and marketplace features; an AI-Assistant overhaul with a Custom-Provider SPI, Tool SPI, `kuml ai bench`, multi-agent orchestration, compliance log, and master-password vault; and renderer improvements for State Machine and Deployment diagrams plus a Windows Chocolatey package.

Plugin Ecosystem — kuml plugin init, Update Commands, Marketplace

  • kuml plugin init <name> --type <category> scaffolds a new plugin project from the kuml-dev/plugin-template — generates a ready-to-compile Gradle module with the correct kuml-plugin.json manifest, a stub SPI implementation, and a sample test. Covers all five categories: theme, renderer, layout, codegen, reverse.
  • kuml plugin update <id> downloads and installs the latest compatible version of an installed plugin from the registry; kuml plugin update --all batch-updates all installed plugins in dependency order.
  • Marketplace improvements: the Registry Browse tab now shows download counts, user ratings, and a kuml-dev verified badge. Plugins can declare keywords in their manifest for improved search ranking.
  • Plugin SPI stability guarantees documented in kuml-plugin-api Javadoc: @PluginApi-annotated interfaces are stable within a minor version; @PluginInternal surfaces may change without notice.

AI Assistant — Custom-Provider SPI, Tool SPI, kuml ai bench

  • New KumlAiProvider SPI in kuml-ai-core: third-party LLM providers can now be plugged in via META-INF/services — same isolation as the plugin system (URLClassLoader per provider). Ships with an example kuml-ai-provider-example module.
  • New KumlAiTool SPI: custom AI tools (beyond the built-in DSL-editor suite) are discoverable at runtime. Tools declare their JSON schema via @AiToolSchema — the agent framework validates arguments before dispatch.
  • kuml ai bench <model.kuml.kts> runs a reproducible LLM benchmark: sends a fixed prompt set to all configured providers, measures round-trip latency and token cost, and writes a Markdown report to bench-results/. Supports --provider <id> to benchmark a single provider.
  • Multi-agent orchestration: KumlAiOrchestrator chains a Planner agent (Claude Opus) → Implementation agent (Claude Sonnet) → Review agent in a typed pipeline. Configurable via kuml ai orchestrate --plan --implement --review.
  • Compliance log: every AI-proposed patch is appended to ~/.kuml/ai-audit.jsonl with timestamp, provider, model, prompt hash, and accept/reject decision — for regulated environments requiring an audit trail.
  • Master-password vault: API keys stored in ~/.kuml/vault.enc (AES-256-GCM, Argon2id KDF). kuml ai vault unlock prompts once per session; subsequent operations use the in-memory key. Falls back to OS Keychain / Windows Credential Manager if available.

State Machine & Deployment Renderer Improvements

  • UML State Machine: history pseudo-states (H / H*) now render as circle-with-H symbols; fork/join bars now scale with the number of concurrent regions rather than using a fixed 80 px width.
  • SysML 2 STM: submachine state references render as a double-bordered rounded box with the referenced state machine name in the footer compartment.
  • C4 Deployment: DeploymentNode nesting depth is now visually encoded — each nesting level adds 4 px of left-pad and a slightly lighter fill, making large deployment trees readable without manual positioning.
  • Deployment diagram edge routing: inter-node edges now avoid crossing into sibling nodes; the ELK INSIDE_SELF_LOOPS constraint is applied per deployment node to keep self-referencing links compact.

Windows Chocolatey Package

  • New kuml-dev/chocolatey-kuml repository: a Chocolatey package for Windows that installs the self-contained kUML distribution via choco install kuml.
  • The package verifies the SHA-256 checksum of the MSI before installation and registers kuml on the system PATH. Uninstall via choco uninstall kuml is fully clean.
  • GitHub Actions workflow publishes new package versions to the Chocolatey Community Repository automatically on each kUML release tag.
v0.16.x1 release
v0.16.02026-06-22

BPMN 2.0 — One DSL for All Models

v0.16.0 adds BPMN 2.0 as kUML's fourth first-class modelling language, alongside UML 2.x, SysML 2 and C4. A standalone pure-Kotlin metamodel, a type-safe @BpmnDsl, OMG-conformant SVG symbols, swimlane collaborations, BPMN 2.0 XML round-trip, a constraint checker, and LaTeX/TikZ output — process modelling as compilable Kotlin code, no XML editor required.

BPMN 2.0 Metamodel + DSL

  • New kuml-metamodel-bpmn module — a standalone pure-Kotlin metamodel, not a UML-activity profile. BpmnEvent uses an Event-Matrix design: a single class carrying a (position × definition × behaviour) triplet covers all ~50 BPMN event variants (13 definitions, 3 positions, 2 behaviours) with init{} guards instead of 36+ subclasses.
  • BpmnGateway (5 types), BpmnTask (7 task types), BpmnSubProcess (expanded/collapsed/transactional/event), BpmnCallActivity, loop markers, SequenceFlow, data objects/stores.
  • Type-safe @BpmnDsl: bpmnModel { process { startEvent(); task(); gateway() } } with an infix flowsTo chain and deterministic auto-generated IDs.

Collaboration, Rendering + Constraints

  • Collaboration support: pools, nested lanes (reference semantics), and message flows. SVG renderer with all OMG symbols — events (thin/double/thick rings), gateways (diamond + 5 type symbols), tasks (rounded rects + type markers), swimlane pools with rotated title bands.
  • BpmnConstraintChecker with 7 rules (missing start/end events, dangling sequence-flow refs, gateway default-flow, boundary-event attachment, message-flow validity, participant process refs).
  • kuml render order-process.kuml.kts --format svg — the CLI auto-detects BPMN models and runs the constraint checker before rendering.

BPMN XML Round-trip + LaTeX

  • New kuml-io-bpmn module: standard OMG BPMN 2.0 XML import/export (JAXB-free, XXE-hardened DOM parser). BpmnXml.export(model) / BpmnXml.import(xml) interoperate with Camunda, Flowable, Zeebe, and bpmn.io.
  • BPMN LaTeX/TikZ renderer with 15 new kuml-bpmn-* styles — kuml render --format latex for all flow-node types and collaborations.

Renderer Improvements

  • C4 LaTeX/TikZ renderer: all 5 C4 diagram types, 6 element types, 10 kuml-c4-* TikZ styles (monochrome default, overridable).
  • Composite-structure: nested-parts rendering fix plus delegation/assembly port connectors (boundary-port → inner-part-port and part-port → part-port).
  • UML associations now render role names alongside the multiplicity at each end.
  • All DSL examples converted to named parameters, reinforcing kUML’s LLM-first design.
v0.15.x1 release
v0.15.02026-06-21

Blockchain-Backed Models

v0.15.0 makes kUML the first modeling tool with native blockchain integration: anchor any .kuml.kts model on-chain (Ethereum/L2, Sui, Aptos), store its canonical SHA-256 hash in a smart contract slot, replay its history as a typed event stream, and prove authorship via EIP-712 signatures. Ships with a DAP governance constitution showcase and a multi-chain merge engine.

Chain-Adapter SPI + ModelHasher (V3.0.1)

  • New kuml-runtime-chain-api module (pure Kotlin, GraalVM Native-Image-compatible): KumlChainAdapter interface — connect(), subscribe(): Flow<ChainEvent>, replay(fromBlock), blockClock().
  • ModelHasher.canonicalize() — deterministic normalisation (CRLF→LF, tab-expansion, blank-line removal); hashCanonical() (SHA-256); hashTransitive() (cycle-safe transitive import hash).
  • kuml fmt --canonical — new flag writing the normalised canonical form instead of the standard formatted output. Enables reproducible hash computation across machines.
  • KumlBackedContractSpec.V1 — machine-readable JSON ABI spec + ContractTestVector.STANDARD_VECTORS for cross-implementation hash verification.

Ethereum / L2 Adapter (V3.0.2)

  • New kuml-runtime-chain-evm (JVM-only, no Web3j): raw java.net.http.HttpClient + kotlinx.serialization.json for all JSON-RPC calls.
  • EvmChainAdapter: eth_getLogs-based paginated replay, finality-aware EvmBlockClock, SSRF-protected URL validation (schema + RFC 1918 / APIPA / ::1 IP blocklist).
  • AbiCodec: pure-Kotlin Keccak-256. Eip712Verifier: EIP-712 typed-data signatures via java.security.Signature (ecrecover, null/all-ones protection).

Sui + Aptos Move-VM Adapters (V3.0.20)

  • New kuml-runtime-chain-move (JVM-only, no native Move SDK): SuiChainAdapter via suix_queryEvents + sui_getObject; Base64-BCS payload decoding; checkpoint-based BlockClock.
  • AptosChainAdapter via Aptos REST API (/v1/accounts/.../events + .../resource); event.data JSON → UTF-8 payloadAbi.
  • MoveAddress value class with 0x + 64-hex normalisation (handles Sui leading-zero-stripped addresses). Both adapters share the same SSRF blocklist as the EVM adapter.

EIP-712 Model Signatures + *.kuml.kts.sig (V3.0.5)

  • ModelSigner.sign(modelSource, privateKeyHex) — EIP-712 TypedData over ModelCommit { modelHash: bytes32, timestamp: uint256 } via secp256k1 ECDSA (pure Java, no Bouncy Castle).
  • ModelSigner.recover() → ecrecover → EIP-55 checksummed Ethereum address. Signature-malleability guard (s ≤ halfN, EIP-2).
  • kuml chain sign <model.kuml.kts> --private-key <hex> writes <model>.kuml.kts.sig. kuml chain verify-sig checks with optional --expected-signer; exits 52 (invalid) or 53 (signer mismatch).

kuml chain CLI + Multi-Chain Merge (V3.0.4, V3.0.21)

  • kuml chain connect — reads ContractIdentity (address, modelUri, schemaVersion, modelHash) from an on-chain contract.
  • kuml chain verify — computes ModelHasher.hashCanonical() locally and compares with the on-chain slot; exit 0 = match, exit 50 = mismatch.
  • kuml chain events [--from-block N] [--limit N] — streams historical events via replay().
  • MultiChainAdapter: parallel connectAll(), subscribeAll() via Flow.merge(), replayAll() sorted by (blockNumber, chainId) for deterministic ordering. Three ConflictResolver strategies: EarliestBlock, PriorityChain, FirstObserved.

DAP Constitution Showcase + Plugin Search (V3.0.6, V3.0.18+)

  • Three .kuml.kts scripts modelling a DAP governance constitution: class diagram, article lifecycle STM (8 states, OCL-guarded transitions), amendment lifecycle STM.
  • Two event-trace JSON fixtures (happy path → IN_KRAFT; quorum-fail → ABGELEHNT) + 14-test showcase with offline EvmChainAdapter round-trip via MockRpcServer.
  • kuml plugin search [query] [--type <category>] — browses the live plugins.kuml.dev registry, filterable by type (theme, renderer, layout, codegen, reverse).
v0.14.x1 release
v0.14.02026-06-17

Structurizr Migration Showcase

v0.14.0 ships the canonical Structurizr migration showcase: the Big Bank Plc reference architecture (Simon Brown) committed as a test fixture, 19 showcase tests exercising `kuml import --format structurizr` end-to-end, and a new handbook page walking through the migration step by step.

Structurizr Migration Showcase (V3.0.19)

  • bigbankplc.dsl fixture — the full Simon Brown Big Bank Plc workspace: 3 persons, 4 software systems (Internet Banking System, Mainframe, E-mail System, ATM), 5 containers (Web App, SPA, Mobile App, API Application, Database), 6 components inside the API Application, and 31 relationships across all elements. Four Structurizr views: System Landscape, System Context, Containers, Components.
  • 19 showcase tests (StructurizrBigBankPlcShowcaseTest) covering workspace metadata, element counts, container and component structure, relationship coverage, view types, and a KumlDslGenerator roundtrip that confirms the output starts with c4Model and contains no Structurizr-specific workspace keyword.
  • Handbook page showcases/structurizr-migration.adoc — step-by-step guide: source workspace summary, kuml import command, generated kUML C4 DSL excerpt, feature-gap table (tags, styles, deployment environments, dynamic views), and next-step sections for rendering, codegen, and AI-assisted editing. Added to the handbook sidebar under Showcases.
  • The kuml import --format structurizr command itself is unchanged — this release adds the documented example and test coverage around the existing importer.
v0.13.x1 release
v0.13.02026-06-17

Plugin Ecosystem + Theme Overhaul

A fully-fledged plugin ecosystem for kUML: six SPI modules (`kuml-plugin-api`), a manifest-driven loader with version-range matching and lifecycle hooks (`kuml-plugin-loader`), a `kuml plugin` CLI with permission enforcement and EdDSA signature verification, an extended Desktop Plugin Manager with Registry Browse, and five reference plugins shipped out of the box (PdV-Theme, PDF-Renderer, ELK-Layout-Bridge, TypeScript-Codegen, TypeScript-Reverse). Plus a Theme Overhaul: new `KumlColors.nodeFill` slot, the editorial `ElegantTheme`, and a pure-white canvas for `KumlBrandTheme`.

Plugin API — 6 SPI modules (V3.0.27–28)

  • New module kuml-plugin-api with six semver-stable SPI sub-modules: core (plugin identity + lifecycle), theme (color/font overrides), renderer (custom SVG emitters), layout (ELK-compatible layout providers), codegen (model-to-source transformers), and reverse (source-to-model parsers).
  • Each plugin runs in its own URLClassLoader — class-space isolation prevents version collisions between host and plugins.
  • SPI contracts are explicitly versioned; kuml-plugin-api publishes a @PluginApi stability annotation so third-party authors know which surfaces are stable across minor releases.

Plugin Loader — manifest, version ranges, lifecycle (V3.0.29)

  • New module kuml-plugin-loader: discovers plugins by scanning for kuml-plugin.json manifests on the plugin classpath.
  • kuml-plugin.json schema: id, version, displayName, description, apiVersionRange (>=3.0.27, <4.0), entryPoint, and optional permissions array.
  • Version-range matching uses SemVer semantics — incompatible plugins are rejected at load time with a clear diagnostic message instead of a ClassCastException at runtime.
  • Plugin lifecycle hooks: onLoad(context) and onUnload() called by the loader on discovery and shutdown respectively. Plugins can register services, open resources, or warm caches in onLoad.

Plugin CLI — kuml plugin subcommand (V3.0.30)

  • kuml plugin list — shows all installed plugins with id, version, type, and load status.
  • kuml plugin install <path-or-url> — installs a plugin from a local JAR or HTTPS URL; verifies EdDSA (Ed25519) signature by default (bypass with --no-verify).
  • kuml plugin remove <id> — uninstalls a plugin; prompts for confirmation.
  • kuml plugin info <id> — shows full plugin metadata including declared permissions.
  • kuml plugin permissions <id> — lists the permission grants for a plugin.
  • kuml plugin reload — hot-reloads all plugins without restarting the process (development workflow).

Permission Enforcement + Signature Verification (V3.0.31)

  • Four permission scopes: render.read-resources (read bundled diagram assets), fs.read / fs.write (file-system access), network.http (outbound HTTP), process.exec (external process launch).
  • Permission enforcement is checked at the call site inside the plugin sandbox — undeclared permissions throw PluginPermissionDeniedException with the plugin id and attempted scope.
  • EdDSA (Ed25519) signature verification via Java 21 java.security — no Bouncy Castle dependency. kuml plugin install verifies the .sig sidecar file against the plugin registry’s public key before writing to the plugin directory.

Desktop Plugin Manager — 5 tabs + Registry Browse (V3.0.32)

  • Plugin Manager extended from 3 to 5 tabs: Theme, Renderer, Layout, Codegen, Reverse — each tab lists plugins of that type with version, source JAR, and load status.
  • New Registry Browse tab: fetches the public plugin registry index over HTTPS and lists available plugins with description and compatibility badge. One-click install triggers the permission dialog before download.
  • Install/Remove flow shows a PluginPermissionsDialog that lists all declared permissions with plain-language descriptions — user must explicitly accept before installation proceeds.

5 Reference Plugins shipped (V3.0.27–32)

  • kuml-plugin-pdv-theme — PdV party branding: Aureolin #FFED00 accent, Black #000000 canvas, Ucla Gold #FAB500 highlights; ships both Light and Dark variants.
  • kuml-plugin-pdf-renderer — renders kUML diagrams to PDF via Apache PDFBox 3.x; declared permissions: fs.write.
  • kuml-plugin-elk-layout — standalone ELK layout bridge plugin; allows third-party apps embedding kuml-core to opt into ELK without bundling it in the main distribution.
  • kuml-plugin-ts-codegen — generates TypeScript interface declarations from UML class diagrams; declared permissions: fs.write.
  • kuml-plugin-ts-reverse — parses TypeScript .ts / .d.ts files and emits a .kuml.kts class diagram; declared permissions: fs.read.

Theme Overhaul — KumlColors.nodeFill, ElegantTheme, BrandTheme (V3.0.27–28)

  • New KumlColors.nodeFill color slot separates node fill from canvas background — previously both derived from background, making it impossible to have a colored canvas with white nodes.
  • New ElegantTheme: editorial-classic palette — creme canvas (#F5F0E8), dark-slate node fills (#2D3142), amber accent (#D4A017). Designed for printed documentation and conference slides.
  • KumlBrandTheme updated: canvas is now pure white (#FFFFFF) instead of the previous off-white; node fills pick up the new nodeFill slot at #F8F9FA.
v0.12.x1 release
v0.12.02026-06-16

AI Assistant, Desktop Distribution, XMI Import/Export

Three major tracks in one release: a Koog-based AI assistant panel built into the Desktop editor (multi-LLM: OpenAI, Anthropic, Google, Ollama), a production-ready Desktop distribution with file I/O, Plugin Manager, and jpackage packaging (DMG / MSI / DEB / RPM), and a new `kuml-io-emf` module with full bidirectional UML ↔ EMF conversion and `kuml import/export --format xmi` CLI integration for Enterprise Architect, Papyrus, and MagicDraw interop.

AI Assistant — Koog-based, multi-LLM (V3.0.22–26)

  • New modules kuml-ai-core and kuml-ai-tools: JetBrains Koog agent framework, @Tool-annotated DSL builder suite, MCP bridge, and a secure API key vault (Keychain / Windows Credential Manager / plain-text fallback).
  • Supports OpenAI (GPT-4o), Anthropic (Claude Sonnet 4), Google (Gemini), DeepSeek, OpenRouter, and Ollama for fully local / offline operation. Privacy mode routes all inference through a local Ollama instance — no data leaves the machine.
  • AI panel in kuml-desktop: streaming responses, collapsible tool-trace cards, per-provider pricing table with token budget tracking, and persistent conversation sessions.
  • Patch apply pipeline: AI-proposed changes go through PatchPreviewDialog with per-element Accept / Reject controls and Accept-All / Reject-All footer. Sandbox validation guards against malformed patches.
  • Optional Langfuse telemetry for cost and latency observability.

Desktop App — Production-ready distribution (V3.0.12–14)

  • File I/O: OS-native Open / Save / Save-As dialogs, MRU recent-files list (max 10, auto-prune missing), persistent window geometry and settings via atomic JSON write (ATOMIC_MOVE + corruption-safe fallback).
  • Plugin Manager UI: three-tab DialogWindow (Themes / Transformers / Reverse Engines) with ServiceLoader introspection, version + source-JAR display, and hot-reload action for development workflows.
  • jpackage distribution: DMG (macOS), MSI (Windows), DEB + RPM (Linux). Self-contained — no JVM required on the end-user machine. Version mapping 0.x.y → x.y.0 satisfies macOS CFBundleShortVersionString constraints.

XMI Import/Export — EA, Papyrus, MagicDraw interop (V3.0.15–17)

  • New optional JVM-only module kuml-io-emf: Eclipse EMF/UML2 bootstrap, EmfToUmlConverter and UmlToEmfConverter with full bidirectional support for Class, Interface, Enumeration (with literals), Property (type, multiplicity, static, read-only), Operation (parameters, return type, abstract, static), Association (both ends + aggregation kind), Generalization, InterfaceRealization, and Dependency.
  • kuml import --format xmi and kuml export --format xmi CLI commands. The module loads via reflection in the Fat-JAR; the GraalVM Native Image binary shows a clear FORMAT_NOT_AVAILABLE error if XMI is attempted.
  • XmiToolFilter strips tool-specific quirks on import: EA EA_Model_ namespace prefixes, Visual Paradigm version-string prefixes. Sample XMI fixtures for EA, Papyrus, and standard UML2 committed to CI resources.
  • EMF/UML2 dependency discovery: UML2 Maven artefacts cap at 5.0.1.v20140910-1354 (Eclipse Nexus); org.eclipse.uml2.uml.resources has no Maven artefact (P2-only) — bootstrap runs via direct EPackage.Registry registration.

Infrastructure — Vault examples CI smoke tests

  • New test module kuml-tests/kuml-vault-examples-tests: 31 Kotest tests that render all 30 vault example .kuml.kts scripts (UML, C4, SysML 2) as SVG + PNG + LaTeX in CI — catches renderer regressions against real-world diagrams.
  • Tests load from committed classpath resources (src/test/resources/vault-examples/), not from a live Obsidian vault — fully reproducible on GitHub Actions.
  • scripts/sync-vault-examples.sh mirrors vault → test resources and extracts kuml code blocks → kuml.dev/playground-sources/ in one command. scripts/watch-vault-examples.sh provides a fswatch-backed file-watcher for live editing sessions.
  • Gradle content-hash-based up-to-date checks: reruns tests only when vault .md content actually changes, not on touch alone.
v0.11.x1 release
v0.11.02026-06-15

Renderer & Layout Overhaul — SEQ, STM, Activity, Component, Package, C4

A broad pass on the SVG renderer and layout bridge, driven by visual defects surfaced in real-world examples. Sequence-diagram fragment frames, STM connection-aware sizing, Activity / Interaction-Overview pseudo-node clipping, UML Component port + contract rendering, UML Package edge endpoint snapping, and new C4 deployment / interaction / description-wrap support.

SysML 2 Sequence — Create-arrow + guard label repositioning

  • MessageKind.Create arrow tips now land on the target lifeline’s head box corner. The SEQ driver detects Create messages and shifts the target’s head box (plus stereotype, name, dashed time-axis start) down by (createSeqNo + 1) * SEQ_MESSAGE_ROW_HEIGHT; bounds.origin.y stays uniform so message Y references remain consistent across all lifelines.
  • Combined-fragment operand guard labels now right-align to the leftmost lifeline (anchor=“end” at minLifelineX - 4). Text grows leftward into a dynamically-sized frame-left-pad zone — sysml2SeqFragmentLeftPad computes max(FRAGMENT_PADDING_H, longestGuardWidth + 12) per fragment.

Sequence fragment frames — asymmetric vertical outsets

  • FRAGMENT_TOP_OUTSET=24f / FRAGMENT_BOTTOM_OUTSET=8f (UML + SysML 2). Root cause: message labels sit 4 px above the arrow line, so the free corridor between two arrows is centered at arrow_n + 8, not at the symmetric midpoint. The new asymmetric outsets land the frame edge exactly in the corridor — adjacent messages are no longer swallowed.
  • New drawLabelWithWhiteBackground helper draws message / self-call / guard labels with a white rect underlay so frame strokes never cut through text.

SysML 2 STM — Connection-aware node sizing

  • Sysml2LayoutBridge.stmContentAwareSizeProvider adds 14 px per incident transition (capped at 112 px) to the docking side of each state. Self-loops count twice. Pseudo-states (Initial / Final) stay 24 × 24. Vertical layouts grow box width, horizontal layouts grow box height.
  • Fixes the Traffic-Light example where state Red had 4 incident transitions and the timer60s / timer5s / powerOff labels stacked on the same pixel row.

Activity & Interaction-Overview — pseudo-node edge clipping

  • New Sysml2ActivityEdgeClipper snaps every routed edge endpoint to the actual visible shape boundary: diamonds for Decision / Merge, fixed-radius circles for Initial / Final / FlowFinal, rectangles for Action / Object / Bar.
  • ELK anchors at the bounding box, which overshoots non-rectangular shapes — arrows used to appear to “float” above the visible shape edge.

UML Component diagrams — Port clipping + Contracts

  • New ComponentPortEdgeClipper clips required / provided interface lollipops and socket arcs at the component port boundary so connector arrowheads land on the port symbol, not on the component body.
  • New UmlComponentContracts SVG layer renders required / provided contracts as separate lollipop / socket shapes attached to ports.
  • ComponentDiagramBuilder gains DSL extensions for inline ports and contracts.

UML Package diagrams — Edge endpoint snapping

  • Package-dependency edges now snap to the body rectangle (y = groupOrigin + tabH, always full-width) instead of the compound-node outer boundary (the folder tab is narrower than the body, so arrowheads landed in the empty notch).
  • Flat (id → KumlElement) index recurses into UmlPackage.members so classes and interfaces declared inside packageOf { … } reach the SVG dispatcher.

C4 — Deployment nodes, Interactions, Description wrap

  • New C4DeploymentNodeSvg renders deployment-node boxes with technology stereotype + nested-container rendering.
  • New C4InteractionSvg renders dynamic-diagram interactions with numbered call-sequence labels.
  • New C4DescriptionWrap greedy word-wrap helper respects max-width per C4 element type so descriptions don’t overflow the box.
  • New C4ContentSizeProvider mirrors the connection-aware heuristic for Person / SoftwareSystem / Container / Component / DeploymentNode.
  • New example: c4/checkout-dynamic.kuml.kts exercises numbered interactions and description-wrap.

Shared rendering primitives

  • New SvgInlineArrow produces <defs>-free inline arrowheads — arrows now embed cleanly into HTML excerpts (handbook, docs) without losing their markers.
  • New TextWrap in kuml-layout-api — language-agnostic word-wrap primitive shared by all C4 / UML / SysML 2 size providers.
  • kuml-cli, kuml-gradle-plugin, kuml-desktop, and kuml-web render pipelines all wire through the new clippers + size providers — every embedding path produces the same SVG for the same source.
v0.10.x1 release
v0.10.02026-06-15

kuml-desktop — Desktop Editor with Live Preview + Renderer Improvements

New standalone kuml-desktop module: edit .kuml.kts scripts with syntax highlighting and watch the SVG re-render in real time — no server required. Plus connection-aware node sizing, SelfLoopRouter for FK self-references, and sequence diagram z-order fix.

New module: kuml-desktop (Track C: V3.0.10 + V3.0.11)

  • Compose Multiplatform Desktop application with RSyntaxTextArea (Kotlin syntax highlighting, code folding, line numbers) and JSVGCanvas (Apache Batik) live-preview pane.
  • 300 ms debounce via Kotlin Coroutines — cancels in-flight render on next keystroke.
  • All 8 diagram types rendered by a standalone DesktopRenderPipeline — no Ktor server dependency.
  • DE/EN i18n via Strings data class; native macOS menu bar.
  • 34 new tests: AppState 4, Strings 4, DesktopRenderController 6, DesktopRenderPipeline 16, DesktopRenderResult 4.

Renderer: Connection-aware node sizing

  • UmlContentSizeProvider rewritten: node boxes now grow with the number of connected edges — 12–16 px per edge per side, capped at a sensible maximum.
  • Eliminates edge-label and multiplicity stacking on hub classes (e.g. PZB BankUsers with 20+ FKs).
  • Horizontal growth for top/bottom edges; vertical growth for left/right edges.

Renderer: SelfLoopRouter + EdgeLabelGeometry + Sequence z-order fix

  • New SelfLoopRouter: replaces ELK’s flat 10-px self-loop with a visible C-shaped arc for FK self-references (e.g. UserPosts.parent → UserPosts).
  • New EdgeLabelGeometry: dedicated geometry helpers for accurate edge-label placement.
  • Sequence diagram z-order fix: combined fragments (alt/opt/loop) rendered before lifeline heads and dashed verticals — fragment frames no longer overpaint time axes.
  • ELK integration updated: ElkGraphBuilder, HintsMapper, ResultMapper support new sizing hints and routing metadata.

DSL & Examples

  • ContainerDiagramBuilder and ClassDiagramBuilder extended with new DSL helpers.
  • New example: PZB database schema (pzb/pzb-database-schema.kuml.kts) — a real-world association-heavy schema that stress-tests connection-aware sizing.
v0.9.x1 release
v0.9.02026-06-14

Reverse Engineering — Java & Kotlin source → UML

End-to-end Source → UML pipeline. Parse existing Java code with JavaParser, Kotlin code with the Kotlin compiler PSI (K2), and emit a clean *.kuml.kts script via the new `kuml reverse` CLI command.

Three new modules — Track B complete (V3.0.7 + V3.0.8 + V3.0.9)

  • kuml-codegen-reverse-api — language-agnostic KumlReverseEngine interface, ReverseRequest/ReverseResult DTOs, ReverseEngineRegistry (ServiceLoader). Pure Kotlin, Native-Image-ready.
  • kuml-codegen-reverse-java — JavaParser-based Java engine. 30 tests, three end-to-end corpora (bank, library, edge).
  • kuml-codegen-reverse-kotlin — Kotlin PSI engine on top of kotlin-compiler-embeddable (K2). 15 mappers, 34 tests, real-world snapshot against kuml-core-model sources.

New CLI: kuml reverse <source-dir>

  • --lang java|kotlin|auto — auto picks the dominant language by file-extension majority (≥ 60 % share).
  • --output <file> writes the generated *.kuml.kts; defaults to stdout.
  • --include/--exclude globs (repeatable), --model-name, --list-engines, --verbose-diagnostics.
  • New UmlModelDslPrinter renders deterministic DSL (enums → interfaces → classes → relationships).
  • Smoke test: kuml reverse kuml-core-model/src/main/kotlin --lang kotlin → 267-line .kuml.kts from 10 production files in ~550 ms.

Kotlin → UML coverage

  • class, abstract, data, sealed, value, inner classes with corresponding stereotypes.
  • interface, fun interface, sealed interface; object and companion object (<<object>>/<<companion>>).
  • Properties: val/var, lateinit, const, by lazy, primary-constructor val/var params.
  • Functions with suspend/inline/operator/infix/tailrec/extension stereotypes; primary + secondary constructors as <<constructor>> operations.
  • Generalization, interface realization, association detection for properties whose type resolves to an internal classifier.
  • Multiplicity inference: List/Set/Flow/Array<T> → 0..*, T? → 0..1, otherwise 1..1.

Diagnostic codes

  • REV-CORE-NNN — engine-agnostic (no sources found, parse failures).
  • REV-J-NNN — Java engine (e.g. REV-J-003 for Map<K,V> skip).
  • REV-K-NNN — Kotlin engine (e.g. REV-K-020 for nested classifiers emitted as top-level, REV-K-050 for supertypes outside the source set).
  • New CLI exit codes: 14 REVERSE_ENGINE_NOT_FOUND, 15 REVERSE_ANALYSIS_FAILED, 16 REVERSE_NO_SOURCES.

Notes

  • Both engines are JVM-only — the Kotlin engine pulls in kotlin-compiler-embeddable (~50 MB). Bundled in the JVM distribution, excluded from the GraalVM Native Image build.
  • 82 new tests across the three waves, all green. ./gradlew check + distTar + runtimeZip + packageDmg all BUILD SUCCESSFUL.
v0.8.x1 release
v0.8.02026-06-11

Runtime trace, sandbox, JetBrains autocomplete, executable widget, ELK default

Runtime trace replay with OTLP export, sandbox guarantees for guards and effects, JetBrains DSL autocomplete (38 items) and rename refactoring, activity trace replay, a Compose Desktop executable behaviour widget — plus ELK back as the default layout engine and a 15-defect renderer quality pass.

Runtime Trace + Replay + OTLP (V2.0.39)

  • New module kuml-runtime-trace: TraceReplayer re-executes a state machine from recorded events and diffs the replay against the original.
  • OtlpExporter converts a TraceFile to OpenTelemetry OTLP-JSON without an external OTel dependency — drop straight into Jaeger or Grafana Tempo.
  • Deterministic FNV-1a span/trace IDs (OtlpIds) for stable golden-file tests.

Sandbox guarantees (V2.0.40)

  • New module kuml-runtime-sandbox: SandboxPolicy controls guardTimeoutMs, maxVariableCount, maxStringLength, and a function allowlist. Ships Strict and Permissive presets.
  • BuiltInFunctions covers log.*, math.*, str.*, list.*, map.*, convert.* — all sandboxed.
  • SandboxValidator lints models against a policy at validation time rather than at run time.

JetBrains — autocomplete + rename refactoring (V2.0.41)

  • 38 DSL completion items for .kuml.kts files grouped by ENTRY / UML / SYSML2 / C4 / SHARED — caret auto-positioned inside the lambda body.
  • KumlRenameExtractor finds all rename candidates for a DSL identifier and powers the IntelliJ rename refactoring action.

Activity trace replay (V2.0.42)

  • TraceFlavourDetector classifies traces as STM / ACTIVITY / EMPTY / MIXED.
  • ActivityTraceReplayer runs ActivityRuntime deterministically from a trace file and diffs decision paths via TraceDiff.

Executable behaviour widget (V2.0.43)

  • New Compose Desktop widget kuml-widget-compose: live in-IDE STM behaviour inspection with scrubbable trace timeline.
  • BehaviourWidgetState manages model + runtime + instance + trace; HighlightHelpers.replayActiveVertices derives the active vertex set.
  • SVG highlight rings around active vertices via SvgRenderOptions.highlightVertexIds — visible in both the widget and the browser UI.
  • EditPolicy (None / GuardsOnly / FullStructural) governs which model edits the widget surfaces.

ELK back as default layout engine

  • All diagram types now use the ELK Sugiyama layout by default — more compact hierarchical placement and better routing for complex diagrams.
  • Use kuml render --layout=grid to opt back into the grid engine (was the default in v0.6.0–v0.7.0 for class/component/use-case diagrams).

Renderer quality pass — 15 defects fixed

  • UML Component ports — 12×12 port squares rendered on component borders with labels.
  • Content-aware sizing — UML Class, Interface, and Component box sizes computed from actual text content (no more labels clipped at box edges).
  • Activity Partitions (swimlanes) — partition lanes now correctly rendered with header labels and contained action nodes.
  • Multiplicity labels — 0..*, 1, 0..1 etc. rendered near association ends.
  • SoaML collaboration — dashed ellipse no longer filled black; fill="none" enforced.
  • PAR constraints — content-aware height from parameter count + expression compartment.
  • SEQ self-call — label no longer clipped at right canvas edge.
  • ALT fragment separators — guard labels of empty operands no longer overlap the previous operand’s last message.
  • C4 z-order — system boundary groups rendered before nodes, not on top of them.
  • Plain stereotypes — stereotypes += "service" assignments now rendered in «» header.
  • STM spacing — increased nodeToNode and edgeToEdge spacing for less-crowded state machine layouts.
v0.7.x1 release
v0.7.02026-06-10

Browser UI, snapshot/restore, code folding, `kuml run`

Browser-based editor and live-preview server, full snapshot/restore for running models, LaTeX download in the web UI, JetBrains code folding, and a new `kuml run` subcommand for interactive and live-mirror execution.

Browser UI — kuml serve

  • kuml serve [--port N] starts a local Ktor server with a browser-based editor and live SVG preview — no IDE required.
  • CodeMirror 6 editor with 300 ms live preview, theme/layout dropdowns, and three bundled example scripts.
  • Download buttons for SVG, PNG, and now LaTeX — choose snippet or standalone .tex via a checkbox.
  • POST /api/render accepts format=latex for all 10 diagram types (UML, C4, all 8 SysML 2); standaloneTex=true wraps output in a \documentclass{standalone} preamble.

Snapshot/Restore + MigrationPolicy

  • StateMachineRuntime.snapshotFull(instance) captures the full runtime state — including the internal event queue, trace, and sequence counter (previously lost on round-trip).
  • restoreFrom(model, snapshot, policy) rebuilds an instance with a configurable MigrationPolicy: Reject (default), AcceptIfFingerprintMatches, or AcceptIfVerticesPresent (allows additive model changes).
  • Same API for ActivityRuntime — activity token distributions persist across restarts.
  • SnapshotIo helpers for file-based persistence; fingerprint is a stable SHA-256 over sorted vertex/transition IDs.

kuml run — interactive and live-mirror execution

  • kuml run <script.kuml.kts> provides three adapters: stdin (interactive REPL — type eventName {payload}, snapshot, status, quit), mcp (local REST server on a free port — five endpoints for programmatic event injection), batch (replay an events JSON file).
  • --restore <snapshot.json> resumes a session from a saved snapshot; --migration controls the policy.
  • --snapshot-out <path> persists the session state on exit — compose with --restore for long-running or resumable simulations.
  • Works with UML state machines, SysML 2 STM, and SysML 2 ACT diagrams.

JetBrains IDE — code folding

  • All major kUML DSL blocks are now foldable in .kuml.kts files: umlModel, classOf, stateMachine, c4Model, sysml2Model, actDiagram, stmDiagram, bdd, ibd, uc, req, seq, par, and 11 more definition-level blocks.
  • Placeholder text shows the first string argument — classOf("User") {…} — for instant navigation without expanding.
  • Guard: only activates on *.kuml.kts files; no impact on other Kotlin files. DumbAware — works during indexing.
v0.6.x1 release
v0.6.02026-06-09

M2M transformers, distribution, JetBrains plugin, MCP runtime

Five M2M transformers, native installers (DEB/RPM/DMG/MSI) and a Docker image, a full JetBrains plugin, five Runtime MCP tools, structural validation, grid layout as default for class/component/use-case diagrams, UML SEQ/STATE renderer-direct paths, LaTeX standalone export, and SDKMAN! on all five platforms.

M2M code generation — 5 transformers

  • kuml transform --transformer <id> generates code from your models: uml-to-jpa (Kotlin JPA @Entity files from UML class diagrams), uml-to-rest (OpenAPI 3.0 YAML — CRUD endpoints + JSON Schema), uml-to-k8s (Kubernetes Deployment + Service manifests per component), uml-to-docker (Dockerfile per component), c4-to-uml (C4 model → UML class diagram script).
  • kuml transform --list-transformers lists available transformers via ServiceLoader registry — plug in custom transformers without patching the CLI.

Grid layout as default

  • Class, component, and use-case diagrams now use the grid layout engine by default — more predictable placement, faster rendering. State diagrams continue to use ELK for compact vertical layouts with curved back-edges.
  • Override with kuml render --layout=elk to restore Sugiyama, or kuml render --layout=auto to let kUML choose per diagram type.

Runtime MCP tools

  • Five MCP tools expose the headless runtime to AI agents and CI pipelines: kuml.run.start, kuml.run.event, kuml.run.snapshot, kuml.run.patch, kuml.run.stop.
  • Drive STM and ACT diagrams from Claude Desktop, scripts, or test harnesses — covers smart home and automotive V2X use cases.

JetBrains IDE plugin — full authoring experience

  • Inline error squiggles (Annotator) in .kuml.kts files with quick-fix suggestions.
  • Live SVG preview pane — 300 ms debounce, zoom/pan via Batik.
  • Structure View showing the diagram element tree.

Distribution — native installers + Docker

  • Install kUML without a JDK: Linux .deb / .rpm packages, macOS .dmg (unsigned), Windows .msi (unsigned) — all via jpackage.
  • Docker: docker pull ghcr.io/kuml-dev/kuml-cli:0.6.0
  • SDKMAN! now covers all five platforms: Mac ARM64, Mac x86_64, Linux x86_64, Linux ARM64, Windows x86_64 — sdk install kuml.

UML Sequence and State Machine renderer

  • SEQ — native sequenceDiagram scripts now render via a renderer-direct path: lifeline heads, combined fragments, and messages are drawn without edge routing through ELK (same architecture as SysML 2 SEQ).
  • STATE — native stateDiagram scripts now render a state machine frame group with correct per-vertex shapes: filled circle (initial pseudostate), donut (final state), rounded box (state) — plus trigger [guard] / effect transition labels.

CLI improvements

  • kuml validate structural checks: duplicate IDs, circular inheritance, dangling references.
  • kuml render --latex-standalone produces a self-contained compilable .tex file.
  • Car2x showcase — V2X intersection scenario runnable via kuml simulate.
  • Handbook fully updated for all V2.x features.
v0.5.x2 releases
v0.5.12026-06-07

SysML 2 polish

Five targeted improvements to the SysML 2 diagram-type series from v0.5.0: edge labels, PNG export, SEQ Combined Fragments, ACT Swimlanes, and `kuml simulate` SysML 2 support.

Improvements

  • Edge labels — UC, REQ, STM, ACT, and PAR diagrams now render stereotype labels, dashed lines, and correct arrowheads
  • PNG export — all 8 SysML 2 diagram types now work with kuml render --format png
  • SEQ — Combined Fragments, Execution Specifications, and Create/Destroy message kinds
  • ACT — Activity Partitions (Swimlanes) and typed input/output Pins on Actions
  • kuml simulate — now accepts SysML 2 state-machine scripts in addition to UML
v0.5.02026-06-06

SysML 2 — complete diagram-type series (8/8)

All eight SysML 2 diagram types are now supported end-to-end. Twelve atomic waves (V2.0.1 → V2.0.12) over the V2 line, with ~263 new tests across the series.

Diagram types

  • BDD — Block Definition Diagram (structural type overview)
  • IBD — Internal Block Diagram (internal wiring of a part)
  • UC — Use Case Diagram (actors + capabilities + include/extend)
  • REQ — Requirement Diagram (traceability: satisfy / verify / derive / contains)
  • STM — State Transition Diagram (states + transitions + entry/exit/do actions)
  • ACT — Activity Diagram (control flow + object flow + 8 node kinds)
  • SEQ — Sequence Diagram (lifelines + sync/async/reply messages)
  • PAR — Parametric Diagram (constraints + binding connectors)

CLI improvements

  • kuml update check — checks GitHub Releases for the latest version
  • kuml update notes — shows release notes for the latest or a specific version
  • kuml render --format latex — TikZ output for LaTeX integration

Distribution

  • SDKMAN! release pipeline added (vendor onboarding in progress — sdk install kuml will be available once the SDKMAN! vendor process completes)
v0.4.x1 release
v0.4.02026-05

Markdown, Pandoc, Maven Central — distribution polish

Markdown integration, Pandoc Lua filter for HTML/PDF rendering, Maven Central publishing for every library module, GitHub Release workflow with git-cliff, and a Homebrew formula template.

Highlights

  • MarkdownProcessor library + kuml markdown CLI with inline / linked-svg / linked-png modes
  • Pandoc Lua filter (tools/pandoc/kuml.lua) for HTML / PDF rendering
  • Maven Central publishing infrastructure for all library modules (apps remain unpublished)
  • GitHub Release workflow with git-cliff changelog generation
  • Homebrew formula template (Formula/kuml.rb)

Documentation

  • Getting-Started guide (docs/getting-started.adoc)
  • Diagram-Type Reference (docs/diagram-types.adoc)
  • LLM benchmark guide + reproducible mock report
  • Release & distribution walkthrough (docs/release.md)
v0.3.x1 release
v0.3.02026-04

UML 2 — all 14 diagram types complete

V1.1 closed the UML 2 diagram-type series. Five built-in profiles, headless state-machine simulator, Structurizr round-trip, and a JVM library on Maven Central.

Highlights

  • UML 2 — all 14 diagram types shipped, structure + behavior
  • Five built-in profiles: AUTOSAR · JavaEE · Spring · OpenAPI · SoaML
  • Headless state-machine simulator (kuml simulate) with deterministic JSON traces
  • Structurizr DSL round-trip (kuml import / kuml export --format structurizr)
  • JVM library on Maven Central; Homebrew tap with self-contained jlink runtime