Skip to content

Visual Notation and Palette Generation Guide

A modelling tool needs to know how to draw each element — what shape, what colour, what icon, and which palette group it belongs to. Hardcoding that per tool doesn't scale across notations. Linked.Archi instead defines visual notation as data in the graph, so any tool can generate a palette by querying it.

This guide explains how that works — from type-level shape/colour/icon defaults to context-aware palettes that render differently for executives, developers, and auditors from the same model.


Overview

Linked.Archi separates visual notation into three layers:

Layer Purpose Where it lives
VisualNotation + defaultStyle Type-level construction recipe *-notation.ttl (per modelling language)
prefVisNotation / altVisNotation Type-level rendered images On element classes or VisualNotation instances
Style (instance-level) Per-diagram-element overrides Model data (user's architecture model)

This separation means: - A palette generator reads the VisualNotation layer to know how to render each concept - A documentation tool reads prefVisNotation to get a quick icon without rendering - A user can override any default via the instance-level Style on their diagram


The Full Flow: PresentationContext → Palette

flowchart TD
    User["User selects audience<br/>(role/preference)"]
    PC["<b>PresentationContext</b><br/>e.g., Executive, Architect, Developer<br/><i>SKOS concept in scheme</i>"]
    NS["<b>NotationSet</b><br/>e.g., ArchiMate 4.0 Standard Notation<br/><i>arch-vis:NotationSet</i>"]
    VN["<b>VisualNotation</b> (per concept)<br/>e.g., :BusinessActorNotation<br/><i>arch-vis:VisualNotation</i>"]
    VNdetail["notationFor → am4:BusinessActor<br/>defaultStyle → Style<br/>prefVisNotation → .../business-actor.svg"]
    Style["<b>Style</b> (construction recipe)<br/>shapeType: RoundedRectangle<br/>fillColor: #FFFFB5<br/>lineColor: #000000<br/>iconSymbol: .../person.svg<br/>iconPlacement: TopRight<br/>defaultWidth: 120 · defaultHeight: 55"]

    User --> PC
    PC -->|"arch:usesNotationSet"| NS
    NS -->|"?vn arch-vis:inNotationSet this-set"| VN
    VN --- VNdetail
    VN -->|"arch-vis:defaultStyle"| Style

Default and Alternative Notation Sets

A metamodel manifest names exactly one notation set with arch:notationSet: the default. RDF statements have no order, so a manifest with two arch:notationSet values gives a tool no way to tell which one is the default. Alternative sets are wired through presentation contexts instead. The manifest names a presentation-context scheme with arch:presentationContextScheme, and each context in that scheme picks a set with arch:usesNotationSet.

The Basic asset set shows the pattern. Its manifest, https://meta.linked.archi/basic/metamodel#Basic, names the rectangle set, https://meta.linked.archi/basic/notation#BasicRectangleNotation, as the default. Its two presentation contexts each pick one set: the Modeller context (https://meta.linked.archi/basic/presentation-contexts#ModellerContext) the rectangle set, and the Workshop participant context (https://meta.linked.archi/basic/presentation-contexts#WorkshopContext) the bubble set, https://meta.linked.archi/basic/notation-bubble#BasicBubbleNotation.

@prefix arch:           <https://meta.linked.archi/core#> .
@prefix basicmm:        <https://meta.linked.archi/basic/metamodel#> .
@prefix basicpc:        <https://meta.linked.archi/basic/presentation-contexts#> .
@prefix basicnot:       <https://meta.linked.archi/basic/notation#> .
@prefix basicnotbubble: <https://meta.linked.archi/basic/notation-bubble#> .

## In basic-metamodel.ttl — one arch:notationSet, the default
basicmm:Basic
    a                              arch:Metamodel ;
    arch:modelConcepts             <https://meta.linked.archi/basic> ;
    arch:notationSet               basicnot:BasicRectangleNotation ;
    arch:presentationContextScheme <https://meta.linked.archi/basic/presentation-contexts#> ;
.

## In basic-presentation-contexts.ttl — each audience picks a set
basicpc:ModellerContext
    arch:usesNotationSet basicnot:BasicRectangleNotation .

basicpc:WorkshopContext
    arch:usesNotationSet basicnotbubble:BasicBubbleNotation .

A tool that loads the manifest follows arch:notationSet to the default set and arch:presentationContextScheme to the contexts. It also has to load every set that a context names with arch:usesNotationSet, because the manifest does not name the alternatives.

Fallback Logic

For a class C, the active set A is the set that the active presentation context names with arch:usesNotationSet, or else the metamodel's arch:notationSet. The fallback layers F are the default sets (arch:notationSet) of all loaded metamodels except A itself, in load order. F includes the default set of A's own metamodel when a presentation context picked an alternative set. That is why EDGY's Overview map reader context still shows Metrics and Tagging in the default set's look: the context picks the v1 set (https://meta.linked.archi/edgy/notation-v1#EDGYStandardNotation), which has no descriptor for them, and step 2 finds them in the EDGY default set (https://meta.linked.archi/edgy/notation#EDGYStandardNotation).

A renderer resolves C's notation in this order:

  1. A descriptor in A for C.
  2. A descriptor for C in F, the first match in load order.
  3. C's own arch:prefVisNotation.
  4. A descriptor for the nearest superclass of C that has one in A or F. The walk goes breadth-first over rdfs:subClassOf: by distance first, and superclasses at the same distance in IRI order. It stops at arch:Element and arch:QualifiedRelationship. For each superclass, A is checked first, then F in load order.
  5. Built-in defaults. Elements: a rectangle with a white fill and a black line. Relationships: a solid black line.

Anything published for the class itself beats anything inherited; among inherited descriptors the nearest ancestor wins; the active set only breaks ties.

With the Basic Workshop participant context active, Basic's own element classes, and any element class that nothing nearer describes, are drawn as bubbles. An ArchiMate relationship keeps its own line and end decorations (step 2). An extension subclass of https://meta.linked.archi/archimate4/onto#BusinessActor with nothing of its own is drawn as a Business Actor, because that descriptor is one step up (step 4), while Basic's arch:Element descriptor is at least two. Subclasses therefore inherit their parent's appearance, as AM-DD-2 expects.


Key Vocabulary

In core-onto.ttl (arch: namespace)

Property Domain Range Purpose
arch:notationSet arch:Metamodel arch-vis:NotationSet Default notation set for the metamodel
arch:usesNotationSet skos:Concept arch-vis:NotationSet Context-specific notation set selection
arch:prefVisNotation skos:Concept schema:ImageObject Rendered composite image (for docs)
arch:altVisNotation skos:Concept schema:ImageObject Alternative rendered images
arch:presentationContextScheme arch:Metamodel skos:ConceptScheme Links to the context scheme

In core-vis-onto.ttl (arch-vis: namespace)

Class/Property Type Purpose
arch-vis:NotationSet Class Named collection of visual notation descriptors
arch-vis:VisualNotation Class Descriptor for one ModelConcept's appearance
arch-vis:Style Class Visual style (extended with shape/icon/mode properties)
arch-vis:RenderingMode Class How shape and icon are composed (ShapeWithBadge, IconCentric, ShapeOnly)
arch-vis:notationFor Property Links VisualNotation → ModelConcept
arch-vis:inNotationSet Property Links VisualNotation → NotationSet
arch-vis:defaultStyle Property Links VisualNotation → Style (the recipe)
arch-vis:shapeType Property Geometric shape (on Style)
arch-vis:iconSymbol Property Icon URI (on Style)
arch-vis:iconPlacement Property Icon position (on Style)
arch-vis:renderingMode Property How to compose shape + icon (on Style)
arch-vis:borderStyle Property Line style of the shape's outline (on Style); solid when absent
arch-vis:fontColor Property Colour of the label (on Style); the line colour when absent
arch-vis:lineStyle Property Line rendering for relationships
arch-vis:sourceDecor Property Source endpoint decoration
arch-vis:targetDecor Property Target endpoint decoration
arch-vis:labelAnchor Property Where along a line its text sits: AnchorSource, AnchorMiddle (when absent), AnchorTarget
arch-vis:image Property A picture drawn inside a node (on Style): an http(s) URL or a data: URI. A picture drawn as the figure is the node's own arch-vis:iconSymbol with arch-vis:renderingMode arch-vis:IconCentric — or, with no iconSymbol of its own, its element's picture for the context (core's arch:prefVisNotation, arch:altVisNotation); drawn as a box with no picture or icon of its own, the node shows its element's picture inside. A style may be for one presentation context (core's arch:inPresentationContext)
arch-vis:useElementPicture Property On a node's own style, true: its icon is its element's picture for the context — its badge in ShapeWithBadge, its figure in IconCentric — in place of the notation's glyph, followed as the picture changes (core-vis 0.8)
arch-vis:labelExpression Property What a label says (an arch-vis:LabelExpression, its text in arch-vis:expression): on a diagram element's style, a concept's notation or a presentation context, for one context (arch:inPresentationContext) or all — see Names, Labels and Pictures per Presentation Context
arch-vis:imagePosition Property Where the picture is drawn: an IconPlacement — a corner, the middle of a side, Center, or Fill; top left when absent

Enumerations

ShapeType: RoundedRectangle, Rectangle, Octagon, Ellipse, Circle, Hexagon, Diamond, Parallelogram — the shapes every renderer draws. A notation declares any other shape it needs in its own namespace (see A notation's own shapes below).

An arch-vis:iconSymbol glyph is drawn over the shape as it is. Its lines are opaque and the parts that show the element's fill are transparent, so one glyph serves every fill colour and every notation set. The ArchiMate glyphs (…/icons/glyphs/) follow the badges in the published pictures, where those parts are painted in the element colour; where such a part covers a line drawn before it, the glyph masks that line instead.

A notation's own shapes

A shape that only one notation draws — ArchiMate's wavy gap, EDGY's arrow, C4's person — is declared in that notation's file, not in core-vis, as an arch-vis:ShapeType individual with:

  • arch-vis:fallbackShape — the core shape a renderer draws when it cannot draw this one;
  • its geometry as path templates, so any renderer can draw it from the data: arch-vis:outlinePath (filled, stroked, and what connectors meet), arch-vis:detailPath (inner lines: stroked, not filled, not outline), arch-vis:contentBox (where the badge and label go) and arch-vis:labelBox (where the label goes when that is elsewhere, such as a folder's tab), with arch-vis:shapeVariables naming values they share.

A template is SVG path data in absolute commands, in the shape's own coordinates — (0,0) at the top left, (w,h) at the bottom right — where any number may be an {expression} over w, h and the variables, with + - * /, parentheses, min() and max(). A box is "x y width height", each a number or an expression.

:Box3D
    a                       arch-vis:ShapeType ;
    skos:prefLabel          "3D Box"@en ;
    arch-vis:fallbackShape  arch-vis:Rectangle ;
    arch-vis:shapeVariables "d = min(h * 0.2, w * 0.2, 12)" ;
    arch-vis:outlinePath    "M0,{d} L{d},0 L{w},0 L{w},{h - d} L{w - d},{h} L0,{h} Z" ;
    arch-vis:detailPath     "M0,{d} L{w - d},{d} L{w - d},{h} M{w - d},{d} L{w},0" ;
    arch-vis:contentBox     "0 {d} {w - d} {h - d}" .

Expressions keep fixed details fixed where a picture has them (a band at most 14 deep, a 3D depth at most 12) and proportional elsewhere, which a stretched picture cannot. The notations that declare shapes this way:

Notation Shapes
ArchiMate 4.0 and 3.2 BandedRectangle, TabbedRectangle, Box3D, WavyRectangle, Cloud, Folder; 3.2 also DoubleBandedRectangle, WavyBandedRectangle
EDGY RightArrow, Pill
C4 Person, MobileDevice, WebBrowser, Cylinder

A shape another notation also needs can move to core-vis then; until a second notation needs it, it belongs to the one that does (DD-32).

Names, labels, pictures and looks per audience

A presentation context changes more than the notation set. What an element is called for an audience is a SKOS-XL name (skosxl:altLabel with core's arch:inPresentationContext), and its picture for an audience a schema:ImageObject given as arch:altVisNotation; what its label says on a diagram is an arch-vis:LabelExpression — text with {…} placeholders for its name, its type and its properties — given on a diagram element's own style, a concept's notation, or the presentation context itself, for one context or for all; and a diagram element may look its own way for an audience, with a style for that context drawn over its style for every context (arch-vis:style is no longer single-valued). A diagram element shows its element's picture for the context: as the figure where it is drawn as its icon (IconCentric), inside the box where it is drawn as one, and in the badge where its style says arch-vis:useElementPicture. All of it follows the context the reader picks, whether or not it picks another notation set. Names, Labels and Pictures per Presentation Context covers every case: the placeholders, where an expression is said, pictures, styles per context, which one applies, and how they are validated.

One look per class; another look for another audience

A notation set gives a class one look. A kind of element that needs a look of its own is a subclass with a descriptor of its own: C4 draws a database as a cylinder because c4:Database is a subclass of c4:Container with its own descriptor, not because of a property value. A different look for a different audience is a different notation set, which a presentation context picks with arch:usesNotationSet (see Default and Alternative Notation Sets). Classes for kinds, sets for perspectives: there is one way to say each (DD-31).

IconPlacement: TopRight, TopLeft, TopCenter, Center, BottomCenter

RenderingMode: ShapeWithBadge, IconCentric, ShapeOnly

LineStyle: SolidLine, DashedLine, DottedLine

Decoration:

Decoration Drawn as ArchiMate uses it for
NoDecoration nothing association; access with no access type
OpenArrowhead two strokes, open serving, influence; access — at the source for read access, the target for write access, both for read-write access
ClosedArrowhead a filled triangle triggering, flow; assignment at the target
HollowArrowhead a white triangle, outlined realization, specialization
HollowDiamond a white diamond, outlined aggregation, at the source (the whole)
FilledDiamond a filled diamond composition, at the source (the whole)
HalfArrowhead one stroke, on one side directed association, at the target
CircleDot a filled dot assignment, at the source

Each decoration except NoDecoration names its marker symbol with arch-vis:decorSymbol (https://meta.linked.archi/core-vis/markers/…svg). A renderer draws the decoration from that symbol: it points in the +x direction, towards the endpoint it decorates; the connector meets it at the middle of the right edge of its viewBox, so a renderer anchors that point on the endpoint and orients the symbol along the connector, mirroring it at a source end; strokes and fills that take the connector's colour are currentColor, and a hollow symbol's interior is white. The published symbols use a 12 × 12 viewBox, drawn at that size.


Rendering Modes

The arch-vis:renderingMode property tells a tool how to compose the shape and icon:

Mode Visual Use Case
ShapeWithBadge Coloured shape + small icon in corner + centred label ArchiMate standard notation
IconCentric Large icon centred + label below AWS/Azure/GCP/K8s vendor icons
ShapeOnly Coloured shape + centred label, no icon Simplified/executive views

ShapeWithBadge (ArchiMate default)

block-beta
    columns 1
    block:shape1["ShapeWithBadge — ArchiMate default"]
        columns 1
        A["⚙ (top-right badge)&emsp;&emsp;&emsp;&emsp;&emsp;"]
        B["Business Actor (label centered)"]
        C["filled #FFFFB5"]
    end

Coloured shape + small icon badge in corner + centred label.

IconCentric (AWS/Azure/GCP)

block-beta
    columns 1
    block:shape2["IconCentric — AWS/Azure/GCP"]
        columns 1
        D["☁️ (large icon IS the element)"]
        E["Amazon EC2 (label below)"]
    end

Large icon centred, label below. The icon IS the element.

ShapeOnly (simplified)

block-beta
    columns 1
    block:shape3["ShapeOnly — simplified/executive"]
        columns 1
        F["Business Actor (label only)"]
        G["filled #FFFFB5, no icon"]
    end

Coloured shape + centred label, no icon.

Rendering Algorithm

A tool implementing element rendering MUST select the algorithm based on the arch-vis:renderingMode value on the Style. Here is the pseudocode for each mode:

Every mode draws the shape the same way:

function drawShape(shapeType, width, height, style):
    if shapeType is a core shape:                       // RoundedRectangle … Parallelogram
        outline = coreOutline(shapeType, width, height); details = none
        contentBox = labelBox = whole shape
    else:                                               // a shape the notation declares
        names = { w: width, h: height } + evaluate(shapeType.shapeVariables)
        outline = fill(shapeType.outlinePath, names)    // {expressions} parsed, never eval'd
        details = fill(shapeType.detailPath, names)
        contentBox = box(shapeType.contentBox, names) or whole shape
        labelBox = box(shapeType.labelBox, names) or contentBox
        on any template error: return drawShape(shapeType.fallbackShape, width, height, style)
    fill(outline, style.fillColor); stroke(outline, style.lineColor, dash(style.borderStyle))
    stroke(details, style.lineColor, dash(style.borderStyle))   // not filled, not docked against
    return { outline, contentBox, labelBox }            // connectors dock against the outline

ShapeWithBadge (default if renderingMode is absent):

function renderShapeWithBadge(element, style):
    shape = drawShape(style.shapeType, style.defaultWidth, style.defaultHeight, style)
    labelColour = style.fontColor or style.lineColor
    centerText(shape.labelBox, element.prefLabel, labelColour)

    if style.iconSymbol exists:
        icon = loadSVG(style.iconSymbol)        // drawn as published: transparent where the fill shows
        resizeIcon(icon, 16px or 24px)          // small badge size
        placeIcon(icon, shape.contentBox, style.iconPlacement)  // e.g., TopRight of the content box

IconCentric:

function renderIconCentric(element, style):
    if style.iconSymbol is missing:
        LOG WARNING "IconCentric requires iconSymbol"
        return renderShapeOnly(element, style)   // fallback

    icon = loadSVG(style.iconSymbol)
    resizeIcon(icon, style.defaultWidth, style.defaultHeight)  // full size
    drawCentered(icon)

    // optional: minimal container for selection/hover
    border = drawShape(Rectangle, style.defaultWidth + padding, style.defaultHeight + padding)
    stroke(border, style.lineColor)
    fill(border, style.fillColor or transparent)

    drawTextBelow(icon, element.prefLabel, style.fontColor or black)   // label BELOW, not inside

ShapeOnly:

function renderShapeOnly(element, style):
    shape = drawShape(style.shapeType, style.defaultWidth, style.defaultHeight, style)
    centerText(shape.labelBox, element.prefLabel, style.fontColor or style.lineColor)
    // NO icon rendering — ignore iconSymbol and iconPlacement entirely

Fallback Rules

Condition Behaviour
renderingMode absent on Style Default to ShapeWithBadge
renderingMode is ShapeWithBadge but iconSymbol absent Render as ShapeOnly (graceful degradation)
renderingMode is IconCentric but iconSymbol absent Log warning, fall back to ShapeOnly
iconPlacement absent but iconSymbol present Default to TopRight
shapeType is a notation's own shape whose templates cannot be read Draw its arch-vis:fallbackShape
shapeType absent, or unknown with no fallback Draw a Rectangle
fontColor absent Draw the label in the line colour (below an IconCentric icon, in black)
borderStyle absent Solid outline

When to Use Each Mode

Mode Use When Examples
ShapeWithBadge The modelling language has a formal notation with coloured shapes and small classifier icons ArchiMate, BPMN, UML
IconCentric The visual identity comes from vendor/product icons that users recognize instantly AWS Architecture Icons, Azure service icons, GCP icons, Kubernetes
ShapeOnly Simplicity is preferred — executive presentations, monochrome printing, high-level overviews Executive dashboards, printed reports, accessibility-focused views

Vendor Icon Sets (AWS, Azure, GCP)

To use vendor icons (AWS Architecture Icons, Azure service icons, etc.), create a notation set with IconCentric rendering mode:

@prefix arch:     <https://meta.linked.archi/core#> .
@prefix arch-vis: <https://meta.linked.archi/core-vis#> .
@prefix am4:      <https://meta.linked.archi/archimate4/onto#> .
@prefix myonto:   <https://meta.linked.archi/mymodel/onto#> .
@prefix :         <https://meta.linked.archi/mymodel/notation-aws#> .

:AWSIconNotation
    a               arch-vis:NotationSet ;
    skos:prefLabel  "AWS Architecture Icons"@en ;
    skos:definition "Renders elements using official AWS Architecture Icon set."@en .

## EC2 Instance (extends am4:Node or a custom class)
:EC2Notation
    a                    arch-vis:VisualNotation ;
    arch-vis:notationFor myonto:EC2Instance ;
    arch-vis:inNotationSet :AWSIconNotation ;
    arch:prefVisNotation  <https://meta.linked.archi/aws/icons/ec2-composed.svg> ;
    arch-vis:defaultStyle [
        a                      arch-vis:Style ;
        arch-vis:renderingMode arch-vis:IconCentric ;
        arch-vis:iconSymbol    "https://d1.awsstatic.com/icons/Arch_Amazon-EC2_64.svg"^^xsd:anyURI ;
        arch-vis:iconPlacement arch-vis:Center ;
        arch-vis:fillColor     "#FFFFFF" ;
        arch-vis:lineColor     "#232F3E" ;
        arch-vis:defaultWidth  "64.0"^^xsd:double ;
        arch-vis:defaultHeight "64.0"^^xsd:double ;
    ] .

## S3 Bucket
:S3Notation
    a                    arch-vis:VisualNotation ;
    arch-vis:notationFor myonto:S3Bucket ;
    arch-vis:inNotationSet :AWSIconNotation ;
    arch-vis:defaultStyle [
        a                      arch-vis:Style ;
        arch-vis:renderingMode arch-vis:IconCentric ;
        arch-vis:iconSymbol    "https://d1.awsstatic.com/icons/Arch_Amazon-S3_64.svg"^^xsd:anyURI ;
        arch-vis:iconPlacement arch-vis:Center ;
        arch-vis:fillColor     "#FFFFFF" ;
        arch-vis:lineColor     "#3F8624" ;
        arch-vis:defaultWidth  "64.0"^^xsd:double ;
        arch-vis:defaultHeight "64.0"^^xsd:double ;
    ] .

## Lambda Function
:LambdaNotation
    a                    arch-vis:VisualNotation ;
    arch-vis:notationFor myonto:LambdaFunction ;
    arch-vis:inNotationSet :AWSIconNotation ;
    arch-vis:defaultStyle [
        a                      arch-vis:Style ;
        arch-vis:renderingMode arch-vis:IconCentric ;
        arch-vis:iconSymbol    "https://d1.awsstatic.com/icons/Arch_AWS-Lambda_64.svg"^^xsd:anyURI ;
        arch-vis:iconPlacement arch-vis:Center ;
        arch-vis:fillColor     "#FFFFFF" ;
        arch-vis:lineColor     "#D86613" ;
        arch-vis:defaultWidth  "64.0"^^xsd:double ;
        arch-vis:defaultHeight "64.0"^^xsd:double ;
    ] .

Then link it to a PresentationContext:

## Developers see AWS icons, architects see ArchiMate notation
mypc:DeveloperContext
    arch:usesNotationSet <https://meta.linked.archi/mymodel/notation-aws#AWSIconNotation> .

mypc:ArchitectContext
    arch:usesNotationSet am4not:ArchiMate40StandardNotation .

The same model, two views: An architect sees rounded rectangles with ArchiMate icons. A developer sees AWS service icons. The underlying RDF data is identical — only the visual rendering changes based on the active PresentationContext.


Example: ArchiMate 4.0

## In archimate4-metamodel.ttl
:ArchiMate4
    arch:notationSet              am4not:ArchiMate40StandardNotation ;
    arch:presentationContextScheme am4pc:ArchiMatePresentationContexts ;
.
## In archimate4-presentation-contexts.ttl
am4pc:ArchitectContext
    arch:usesNotationSet am4not:ArchiMate40StandardNotation .

am4pc:ExecutiveContext
    arch:usesNotationSet am4not:ArchiMate40StandardNotation .   # an organisation may link a simplified set here

VisualNotation defines the appearance

## In archimate4-notation.ttl
:BusinessActorNotation
    a                    arch-vis:VisualNotation ;
    arch-vis:notationFor am4:BusinessActor ;
    arch-vis:inNotationSet :ArchiMate40StandardNotation ;
    arch:prefVisNotation  <https://meta.linked.archi/archimate4/icons/business-actor.svg> ;
    arch-vis:defaultStyle [
        a                      arch-vis:Style ;
        arch-vis:shapeType     arch-vis:Rectangle ;
        arch-vis:fillColor     "#FFFFB5" ;
        arch-vis:lineColor     "#000000" ;
        arch-vis:renderingMode arch-vis:ShapeWithBadge ;
        arch-vis:iconSymbol    "https://meta.linked.archi/archimate4/icons/glyphs/actor.svg"^^xsd:anyURI ;
        arch-vis:iconPlacement arch-vis:TopRight ;
        arch-vis:defaultWidth  "120.0"^^xsd:double ;
        arch-vis:defaultHeight "55.0"^^xsd:double ;
    ] ;
.

## In archimate3.2-notation.ttl: a gap is drawn as a wavy box, a shape the ArchiMate
## notation declares itself (see "A notation's own shapes"), its glyph as its badge.
:GapNotation
    a                    arch-vis:VisualNotation ;
    arch-vis:notationFor am:Gap ;
    arch-vis:inNotationSet :ArchiMate32StandardNotation ;
    arch-vis:defaultStyle [
        a                      arch-vis:Style ;
        arch-vis:shapeType     :WavyRectangle ;
        arch-vis:fillColor     "#E0FFE0" ;
        arch-vis:renderingMode arch-vis:ShapeWithBadge ;
        arch-vis:iconSymbol    "https://meta.linked.archi/archimate3/icons/glyphs/gap.svg"^^xsd:anyURI ;
    ] ;
.

By default every ArchiMate element is drawn as a box with its glyph as its badge — square for a structure element, rounded for behaviour and a work package, its corners cut for a motivation element (meaning and value included) — and only the junctions, too small for a badge, without one. A business or data object, a product, a contract, a representation and a deliverable are square boxes; a device, equipment, a facility and a plateau flat ones; a gap (3.2) keeps its wavy box, with its glyph. A grouping is a dashed box with its folder glyph, its name at its top left (arch-vis:textAlignment arch-vis:AlignLeft, arch-vis:textPosition arch-vis:PositionTop). The banded, tabbed, wavy and 3D boxes, the cloud and the folder are declared as the arch-vis:alternativeStyle of the types that may also be drawn so. An alternative says only what differs: its shape type and rendering mode (an outline's style). A diagram element drawn as one says so on its own style, with the alternative's arch-vis:shapeType and arch-vis:renderingMode:

:BusinessObjectNotation
    arch-vis:alternativeStyle [
        a                      arch-vis:Style ;
        arch-vis:shapeType     :BandedRectangle ;
        arch-vis:renderingMode arch-vis:ShapeOnly ;
    ] .

## One business object, drawn as its banded box in a view:
ex:OrderNode arch-vis:style [
    a                      arch-vis:Style ;
    arch-vis:shapeType     <https://meta.linked.archi/archimate4/notation#BandedRectangle> ;
    arch-vis:renderingMode arch-vis:ShapeOnly ;
] .

Relationship notation (on the relationship class)

## In archimate4-notation.ttl
:ServingNotation
    a                    arch-vis:VisualNotation ;
    arch-vis:notationFor am4:Serving ;
    arch-vis:inNotationSet :ArchiMate40StandardNotation ;
    arch-vis:lineStyle    arch-vis:SolidLine ;
    arch-vis:sourceDecor  arch-vis:NoDecoration ;
    arch-vis:targetDecor  arch-vis:OpenArrowhead ;
.

Relationship notations carry no colour. Renderers draw relationships black, and relationship types differ by line style and end decorations only. A notation may say where the name sits along the line (arch-vis:labelAnchor: AnchorSource, AnchorMiddle, AnchorTarget); absent, at its middle.


SPARQL: Palette Generation Query

PREFIX arch:     <https://meta.linked.archi/core#>
PREFIX arch-vis: <https://meta.linked.archi/core-vis#>
PREFIX skos:     <http://www.w3.org/2004/02/skos/core#>
PREFIX am4not:   <https://meta.linked.archi/archimate4/notation#>

# Get all element notations for the standard notation set
SELECT ?concept ?label ?shape ?fill ?icon ?iconPos ?renderMode ?width ?height ?image
WHERE {
    ?vn a arch-vis:VisualNotation ;
        arch-vis:inNotationSet am4not:ArchiMate40StandardNotation ;
        arch-vis:notationFor ?concept ;
        arch-vis:defaultStyle ?style .

    ?concept skos:prefLabel ?label .
    FILTER(lang(?label) = "en")

    ?style arch-vis:shapeType ?shape ;
           arch-vis:fillColor ?fill ;
           arch-vis:defaultWidth ?width ;
           arch-vis:defaultHeight ?height .

    OPTIONAL { ?style arch-vis:renderingMode ?renderMode }
    OPTIONAL { ?style arch-vis:iconSymbol ?icon }
    OPTIONAL { ?style arch-vis:iconPlacement ?iconPos }
    OPTIONAL { ?vn arch:prefVisNotation ?image }
}
ORDER BY ?label

Creating Alternative Notation Sets

To create a simplified notation for executives:

  1. Create a new file (e.g., archimate4-notation-simplified.ttl)
  2. Define a new NotationSet individual
  3. Create VisualNotation instances with simpler styles (no icons, flat colours)
  4. Link the PresentationContext to the new set. A shape the new set needs beyond the core ones is declared in its file too, with a fallback and its templates (see A notation's own shapes)
  5. Leave the manifest's arch:notationSet alone. Do not add the new set as a second arch:notationSet: the manifest keeps exactly one, the default, and the new set is reached only through the presentation context
:ArchiMate40SimplifiedNotation
    a               arch-vis:NotationSet ;
    skos:prefLabel  "ArchiMate 4.0 Simplified Notation"@en ;
    skos:definition "Simplified notation for executive presentations — flat shapes, no icons."@en ;
.

:BusinessActorSimplifiedNotation
    a                    arch-vis:VisualNotation ;
    arch-vis:notationFor am4:BusinessActor ;
    arch-vis:inNotationSet :ArchiMate40SimplifiedNotation ;
    arch-vis:defaultStyle [
        a                      arch-vis:Style ;
        arch-vis:shapeType     arch-vis:RoundedRectangle ;
        arch-vis:fillColor     "#FFFFB5" ;
        arch-vis:lineColor     "#666666" ;
        ## No icon — simplified
        arch-vis:defaultWidth  "100.0"^^xsd:double ;
        arch-vis:defaultHeight "40.0"^^xsd:double ;
    ] ;
.

Then update the PresentationContext:

am4pc:ExecutiveContext
    arch:usesNotationSet am4not:ArchiMate40SimplifiedNotation .

Regenerating Notation Files

The notation TTL files and SVG icons are static authored assets maintained alongside the ontology files. They are not generated from an external source — edit them directly when adding elements or changing visual properties. A notation file also declares the shapes its notation draws beyond the core ones (ArchiMate's, EDGY's and C4's do).

C4, EDGY and Basic notation files and icons are maintained in their respective directories: - modelingLanguages/c4/c4-notation.ttl + modelingLanguages/c4/icons/ - modelingLanguages/edgy/edgy-notation.ttl + modelingLanguages/edgy/icons/ - modelingLanguages/basic/basic-notation.ttl + modelingLanguages/basic/icons/ - modelingLanguages/basic/notation-bubble/basic-notation-bubble.ttl + modelingLanguages/basic/notation-bubble/icons/

SVG icons live alongside the notation TTL files in the modelling language directory so they are committed to the repository and deployed by the CI pipeline.

Deployment and URI Resolution

Icon URIs in the notation files reference the published site (e.g., https://meta.linked.archi/archimate4/icons/business-actor.svg). The CI pipeline copies icons from their source locations into the deployed site:

Source path Deployed to URI prefix
core/icons/markers/ public/core-vis/markers/ https://meta.linked.archi/core-vis/markers/
modelingLanguages/archimate/4.0/icons/ public/archimate4/icons/ https://meta.linked.archi/archimate4/icons/
modelingLanguages/archimate/3.2/icons/ public/archimate3/icons/ https://meta.linked.archi/archimate3/icons/
modelingLanguages/c4/icons/ public/c4/icons/ https://meta.linked.archi/c4/icons/
modelingLanguages/edgy/icons/ public/edgy/icons/ https://meta.linked.archi/edgy/icons/
modelingLanguages/edgy/notation-v1/icons/ public/edgy/notation-v1/icons/ https://meta.linked.archi/edgy/notation-v1/icons/
modelingLanguages/basic/icons/ public/basic/icons/ https://meta.linked.archi/basic/icons/
modelingLanguages/basic/notation-bubble/icons/ public/basic/notation-bubble/icons/ https://meta.linked.archi/basic/notation-bubble/icons/

This applies to both GitLab Pages and the server deployment (both use the same public/ artifact).

For local/offline use, resolve https://meta.linked.archi/ to the repo root — e.g., https://meta.linked.archi/archimate4/icons/business-actor.svg maps to modelingLanguages/archimate/4.0/icons/business-actor.svg.


References