Skip to content

Examples ​

Diagrams has a card for every type umlimator draws. Each opens the type's page: one example, live, that shows everything the type draws in one picture, with a checklist of what to find in it. Atlas shows whole businesses, each modelled as one model in many views of many types that open into each other. In an app, at the end, shows the module inside host pages. On any diagram you can pan, zoom, select and go into the cards that stack.

Diagrams ​

The map, then the 28 types in the order of the Diagram types page. Each card opens the type's page; its list names the first things the diagram shows.

Maps ​

Map

Layered architecture maps: cards, lines and boxes in views that open into each other, with stories, tours and lenses.

  • The view's title and caption over the map
  • A card drawn by its kind: person (Shoppers), user (Shop staff), terminal (Admin CLI), browser app (Storefront), phone (Shop app), folder (Pricing), hexagon (Fraud check), cylinder (Orders), pipe (Order queue), robot (Support agent), page with a folded corner (returns.md), box in perspective (Hosts), dashed external card (Card gateway)
  • A card's own shape over its kind: Back office drawn as a window
  • 16 more

Opens on The bookshop's systems; also An order, in run order

UML structure ​

Package

Packages and the dependencies between them.

  • Open packages drawn as boxes holding their elements, each name in a tab at the top left (fulfilment, sales, payments, catalog, shared)
  • A qualified name for an element whose own package the view does not show (couriers::Courier inside fulfilment)
  • A closed package, a folder with an empty tab and its name in the body (reporting, whose contents are not shown)
  • 10 more

Opens on Bookshop packages; also Bookshop packages, laid out right

Composite structure

The parts inside a class, their ports and connectors.

  • The subject, OrderService, as a box with its name in the top left
  • Ports on the subject's border, each pinned to a side with present side: api on the left, payments on the right
  • Parts as rectangles name : Type [multiplicity]: checkout : CheckoutFlow [1], pricing : PriceCalculator [1], orders : OrderRepository [1]
  • 11 more

Opens on Inside the bookshop's OrderService; also The same structure, laid out down, PublishSubscribe as the subject

Deployment

Nodes, execution environments and the artifacts deployed on them.

  • A device drawn as a cube with <<device>> over its name (Shopper's device, Application server)
  • An execution environment nested in a device, <<executionEnvironment>> over its name (Web browser, Java 21 runtime)
  • Artifacts deployed by nesting, <<artifact>> over the name with the document icon (storefront.js, order-worker.jar, shop-api.jar)
  • 10 more

Opens on The bookshop in production; also The same deployment, laid out right

Profile

Stereotypes that extend UML for a domain.

  • A package drawn as a box holding classes (sales), a closed package inside it with a stereotype over its name (<<module>> payments)
  • A class with two stereotypes over its name, one from another profile qualified by it (<<aggregateRoot>>, <<Audit::record>> on Order)
  • A tag compartment per stereotype, headed <<name>>, each row tag = value, inherited tags included (retainDays, table, boundedContext)
  • 13 more

Opens on The bookshop's modelling conventions; also The same conventions, laid out right

UML behaviour ​

Interaction overview

An activity whose steps are interactions.

  • An initial node, a filled circle
  • Interaction uses, boxes with ref in their tag, each opening its sequence diagram (Find a book, Check out, Email the receipt, Reserve the stock)
  • A control flow with a name as its label (book chosen)
  • 10 more

Opens on Buying a book; also Buying a book, laid out right, Find a book, Check out, Reserve the stock, Email the receipt, Queue the order

SysML ​

Requirement

Requirements and how they are derived, satisfied and verified.

  • The req frame with its pentagon header, the view's subject a package: req [Package] Online bookshop [What the shop must do]
  • Requirements as classifiers, <<requirement>> over the name and an id and text compartment (SHOP-1 Online ordering)
  • Containment, a line with a crosshair at the owner's end, two levels deep (Online ordering holds Search, Checkout and Refunds; Search holds Search speed)
  • 12 more

Opens on What the shop must do

Internal block

The parts of a block and what flows between their ports.

  • The frame: the subject block's box with its header ibd [Block] EBike [Inside the e-bike]
  • A port on the frame's own border (<<proxy>> chargeSocket : ChargeInterface) and a connector delegating it to a part's port
  • Proxy ports typed by an interface block, with a two-way flow arrow inside from its in and out flow properties (charge : ChargeInterface)
  • 10 more

Opens on Inside the e-bike; also Inside the e-bike, laid out right

Parametric

Constraint blocks that bind a system's values.

  • The frame's header naming its block: par [Block] EBike [...]
  • Value properties as plain boxes name : Type (ecoConsumption : EnergyPerDistance, batteryCapacity : Energy)
  • Constraint properties as boxes with rounded corners, name : ConstraintBlock, the block's expression in braces under the name, cut to the box
  • 4 more

Opens on The e-bike's range in eco and boost; also The same analysis, laid out down, TripRange, a constraint block as the frame

Architecture, data and process ​

C4

C4's landscape, context, container, component, dynamic and deployment views.

  • People in C4's person shape, with their description (Shopper, Shop staff)
  • The subject's boundary, a dashed box titled Bookshop [Software System], holding its containers
  • Containers with C4's three lines: the name, [Container: technology] and the description
  • 9 more

Opens on Bookshop: containers; also Bookshop: system context, The bookshop's systems: landscape, Shop API: components, Placing an order, Bookshop: production deployment

Entity-relationship

Entities, their attributes and relationships, with cardinality.

  • Tables as boxes, the name in a header, the key columns above a divider and the rest below it
  • Column marks: PK, FK, UK and ? for a nullable column (customer's referred_by is FK ?)
  • A composite primary key whose part is also a foreign key (order_line: order_id PK FK, line_no PK)
  • 12 more

Opens on A bookshop's database; also The same database in IDEF1X

BPMN

Business processes: events, tasks, gateways, pools and lanes.

  • Pools as bands, each name turned in a header strip: Shopper, Payment provider, Bookshop
  • A black-box pool with no flow nodes (Payment provider)
  • A none start event (Basket is ready) and a user task with the figure at its top left (Place order)
  • 22 more

Opens on A bookshop order, from basket to shipment; also Pick and pack, the collapsed sub-process opened, The same process, Pick and pack expanded

Cloud architecture ​

AWS

Accounts, regions, VPCs, subnets and the services in them.

  • A resource outside the cloud with its icon and full name (Shoppers, Users)
  • Connections, solid with an open arrow and a label (looks up, HTTPS, storefront, /api)
  • The cloud group, AWS Cloud [Cloud], holding global services (DNS, Amazon Route 53; CDN, Amazon CloudFront)
  • 11 more

Opens on The bookshop on AWS

Azure

Subscriptions, resource groups, virtual networks and the services in them.

  • Groups as boxes nested by ownership, each titled with its kind: a subscription, a resource group, a region (dashed), a virtual network and subnets
  • Service cards: the vendor icon on its tile (a plain square where no icon pack was fetched), the label, and the full service name under it in a smaller muted line (CDN and routing, Front Door and CDN Profiles)
  • Connectors, solid with an open arrow and a label (storefront, /api, paid order)
  • 6 more

Opens on Bookshop on Azure

Atlas ​

Whole businesses, each one model in many views of the types above, joined by cards that open them.

The Umlimator Atlas

Umlimator's own model, drawn with umlimator: its parts and who uses each (a map), its system context and containers (C4), the core module's packages in build order (a package diagram), the typed diagram families (a component diagram), the diff Action on a pull request (a sequence diagram) and umlimator's state machines (navigation, the story player, tours, the page's keys and the MCP page), joined by cards that open them.

Its views, by type: Map (Umlimator, umlimator's state machines, Navigation, Story player, Tour and replay, The page's keys, The MCP page); C4 (umlimator: system context, umlimator: containers); Package (The module's packages, in build order); Component (umlimator/all: the typed families); Sequence (The diff Action on a pull request).

The Bookshop Atlas

An online bookshop modelled end to end as one model: a map of its systems and the people around them opens into its C4 views, the shopper's use cases, buying a book step by step, its components and sales domain, an order's life, the database, the data flows, fulfilling and paying, the order's way from basket to courier in BPMN, returns, the deployment in production and on three clouds, and the plan for opening the shop. The same names run through every view.

Its views, by type: Map (Bookshop); C4 (Bookshop: system context, Bookshop: containers, Shop API: components, Placing an order, Bookshop: production deployment); Use case (Shopping); Interaction overview (Buying a book); Sequence (Find a book, Check out, Email the receipt, Queue the order, Checkout); Component (Bookshop components); Class (Sales domain, Payments only); State machine (An order's life); Object (Order 1042, just placed); Package (Bookshop packages); Profile (Bookshop conventions profile); Composite structure (Inside OrderService); Information flow (What travels with an order); Entity-relationship (Bookshop schema); Data flow (Bookshop, level 1, 1 Take order); Activity (Fulfilling an order, Take payment); Timing (One charge); Communication (Checkout: payment accepted); BPMN (From order to shipment, Pick and pack); Flowchart (Handling a returned book); Deployment (Production); Mindmap (Opening the bookshop); Google Cloud (Bookshop on Google Cloud); Azure (Bookshop on Azure); AWS (Bookshop on AWS).

In an app ​

PlaygroundEdit a model and see the map, its problems (validate()), its broken rules (rules()) and its layout check (check()); share it by link.
The element<umlimator-map src="...">: a map from HTML alone, its still shown until it is drawn; the block a docs site (VitePress, Docusaurus, MkDocs) turns into it.
A host pagerender() with the standalone page's pieces (views list, details panel, legend, hint line), views loaded when opened, SVG and PNG export, themes and the minimap.
Live trafficoverlay() every second: flow as fast as the traffic, errors that pulse, slow lines that glow, lag on each card; the model never changes.
Ask the mapQuestions answered with words, the paths or reach they are about lit, and a tour; the view in sentences (describe()) for an AI model.
Trace replayAn OpenTelemetry trace played on the map: each call along its line at its time, with its duration.
EditingThe map emits change events; the host applies them and keeps an undo history.
A class diagram editorA class diagram emits edit events, each a transaction of commands; the host applies them with apply() and keeps history() for undo and redo.
A time-lapseFour releases on a slider: new cards fade in, removed ones fade out, moved ones glide; diff() says what changed.
Drawn vs. seendrift(): the map against a week of traffic; lines that ran undrawn come in, idle ones fade.
In Nodelayout() without a browser, as a check a host can run in CI on maps it generates.