Arcalyse — your model, inside and out
Standalone application (a single HTML file) to explore, analyse, check and export a Capella / ARCADIA model without opening Capella. The .capella file is read locally in the browser.
Opening a model
- Drag and drop your model file — Capella (
.capella, .melodymodeller, .xml) or SysML v2 (.sysml, .kpar) — anywhere in the window, or click 📂 Model file… on the home screen (or 📁 File › 📂 Open a model…; the accepted formats are listed under the buttons). 📁 Project folder… (or 📁 File › 📁 Open the project folder…, or a dropped folder, in Edge / Chrome) loads the project at once: the .capella with its .aird diagrams and its libraries, or the .sysml files of a SysML v2 project; if it contains several models, you choose which one. Commands specific to Capella (🔄 update, 🔄 file watch) say so in their label.
- The model is analysed, then the project 🏠 Home view opens automatically (information, checklists, review plans, review packages).
- New toolbar (3.0): views are grouped by purpose — direct buttons 🏠 Home, 🔲 Diagrams, ▤ Table, then the 🏗 Architecture, ✅ Check and 💬 Review & documents menus — and the 🔍 field (Ctrl+K) finds a view, an element or a diagram. Essential (default) shows the most used views; Full adds the advanced views.
- To change model, simply drop another file (it replaces the displayed model).
- For a new version of the same model: 📁 File › 🔄 Load a model update shows the delta first, then updates after confirmation (see 🔄 Watch).
- New version of Arcalyse: 📄 Work project (.html)… on the welcome screen (or 📁 File › 📄 Open a work project, or the page dropped on the window) carries over a page saved with an earlier version (2.1 or later): model, diagrams, review, home, dashboards, ▤ Table, views, bar, theme, naming rules, as you choose. The page is not executed: only its data is read. Under Edge / Chrome, Ctrl+S can then rewrite the same file, now in the new version.
First time? On the home screen, 🚀 Getting started shows where to open your file, then resumes once the model is loaded to show where to find the help and tutorials. ❓ Help ▾ › 🎓 Guided tour presents each area of the interface step by step (more complete with a loaded model). In each view, ❓ Help ▾ › 🎯 Tour of this view presents its menus and what they do.
Only the semantic .capella file is read. .aird (diagrams) and .afm files are refused: they do not contain the model elements.
The main areas
🗺 Relation MapInteractive graph centred on an element and its neighbours, filterable by types and relations.
▤ TableAll model elements in a table: view tabs, attribute, relation and path columns, sort, filters, CSV export.
🔷 Capella viewsDedicated analysis views: explorer (tree, cards, index), links, chains, interfaces, ports, index.
Saving and sharing
⚠ When a model is loaded, the browser asks for confirmation before leaving the page (← Back button, closing the tab): otherwise the work in progress would be lost. Remember to 💾 Save.
💾 Save (Ctrl+S) writes the page directly to a file chosen once, then overwrites it at each save, without going through downloads (Edge / Chrome; elsewhere, the page is downloaded). Shift+click or Ctrl+Shift+S: save as. 💾 HTML page downloads the page. In both cases, the whole application is saved with the embedded model. When this file is opened, the model reloads by itself: handy to freeze a state or share an analysis with someone who does not have Capella.
The saved page contains: the model and its diagrams (.aird), the 🏠 home (project sheet, checklists, review plans, review packages and their feedback), the 💬 Review comments, the view bar (menus, pins), the dashboards, the ▤ Table tabs and columns (path columns, filters, widths, sort), the theme and the naming rules. Not kept: the version loaded for ⚖ Comparison and the filters of the other views.
📁 File › ⚙ Save the interface and views: the same settings without the model, in a .json file (parts of your choice); ⚙ Load an interface and views applies them again, for example with another model or a new version of the page.
Offline operation
The application works without a connection: all resources are embedded in the file, including the D3.js v7.9.0 graphics library (ISC licence). Exports (PDF, ZIP, PNG, SVG, CSV, HTML) are generated in the browser, without any external library, and the HTML reports produced are standalone too. A saved 💾 HTML page remains usable offline.
Toolbar
Level 1 — always visible
| ◀ ▶ | Navigation history (Alt+← / Alt+→; right-click: list of steps). |
| 🏠 · 🔲 · ▤ | Direct buttons: 🏠 Home, 🔲 Capella diagrams, ▤ Table (and the views you pin with 📌). |
| 🏗 ▾ · ✅ ▾ · 💬 ▾ | View menus, grouped by purpose: 🏗 Architecture (how the system is built, 🗺 Relation Map included), ✅ Check (health, checks, traceability, requirements, comparison…), 💬 Review & documents (comments — the badge counts those not closed —, checklists, files to send for review, reports, dashboards). Details in the Capella views tab. |
| 🔍 (Ctrl K) | Search for a view, a model element or a diagram; with no text, all views. |
| Essential · Full | Menu display level: the most used views (default), or all views. |
| With no model open, the toolbar is reduced to 📁 File, ❓ Help and ⚙. |
| 📁 File ▾ | 🔷 Open a Capella model: replaces the displayed model. 🔄 Load a model update: compares another file with the displayed model, shows the delta and updates after confirmation; if fewer than half of the elements are shared, a warning says it may not be the same project. 💾 Save (Ctrl+S) / Save as… (Ctrl+Shift+S) / 🌐 Download the HTML page: standalone page containing the model, the view bar, the dashboards, the ▤ Table tabs and columns, the theme, the naming rules and the 💬 Review comments. If a model is already open, a warning appears before the file picker: unsaved work will be lost; 💾 Save the page, then 📂 Choose the .capella file…. ⚙ Save / Load the interface and views: the same settings without the model, in a .json file, parts of your choice, to reuse them with another model. |
| 💾 | Direct save (Ctrl+S; Shift+click or Ctrl+Shift+S: save as). |
| 🔄 | New versions of the .capella file (see below): the button only appears, with its badge, when a new version is detected; the menu opens from 📁 File › 🔄 File watch. |
| ⚙ › 🎨 Theme | Dark (default), Light, Office 2007, Contrast (🌊 Navy and 🌿 Nature have been removed: a page that used them switches to Dark). Views are redrawn with suitable colours; in a light theme (Office 2007, Light or light custom), coloured texts are automatically darkened to stay readable. |
| ⚙ › 🎨 Theme › Customize… | Custom theme: all colours (backgrounds, texts, accent, borders, statuses, Relation Map, ARCADIA layers), live preview, “Start from” an existing theme, displayed text contrast, ⬇ / ⬆ JSON. It then appears as “🎨 Custom” in the list and is kept in the saved page. |
| 🌐 FR / EN | Multilingual version (arcalyse-multi.html) only: switches to the other language (toolbar button or home screen link). The page is reloaded and the loaded model is kept; the ?lang=fr or ?lang=en address also selects the language. Without a choice, the browser language is used. |
| ⬇ Export ▾ | Export of the Relation Map graph (2nd Relation Map bar): image PNG, JPEG or SVG, or CSV data (see below). |
| ❓ Help ▾ | 📖 Full help: this documentation; 🎯 Tour of this view: presentation of the menus and commands of the displayed view (Relation Map, each Capella view; model loaded); 🎓 Guided tour: step-by-step discovery of the interface (highlighted area, rest of the screen darkened; ◀ Previous / Next ▶ or the arrow keys, ✕ or Esc to quit). Both are also available from the home screen. ℹ About: version, author, licence (Apache 2.0), contact, third-party components (D3.js licence), technical information to copy for an issue report (including the test browser: Google Chrome version 155). |
Level 2 — Relation Map commands
Displayed only in 🗺 Relation Map mode.
| ＋ / － / ⊡ Fit | Zoom in, zoom out, fit to window. |
| ⚙ Filters | Drawer above the graph, in two columns: Element types (colours by ARCADIA layer, number of elements) and Relation criteria (Capella relations to follow). Search in each column, ☑ / ☐ check or uncheck all, groups can be checked as a whole, “checked / total” counters (also on the button). × or Esc closes it. |
| ↓ Open all / ↑ Close all | Expands or collapses all the graph nodes. |
| Depth − n + | Neighbourhood depth around the context element (1 to 10). |
| → LR ▾ (layout) | Graph layout menu: → LR, ↓ TB, ← RL, ◉ radial, ⚡ zigzag (for reading sequences); the button shows the current layout. |
| # Nums | Numbers on the relations. |
| ◉ Legend | Shows or hides the legend: only the relations present in the displayed graph, with their count; a click on its title collapses it. |
| ⌁ Relations | Relation names on the edges. |
| ✂ Names | Cuts names that are too long. |
| ⊙ Single | On by default: each element is expanded only once, at its shortest distance from the context; its other occurrences stay displayed, greyed out and collapsed (↺) — a click on one selects the first occurrence and centres the view on it. Off: each branch expands everything again. In both cases, several relations of the same type towards the same element (e.g. several exchanges between two functions) form a single edge, marked “×n” when ⌁ Relations is on. |
| ⬡ Compact | Shrunk nodes. |
| ⬇ Export ▾ › ▦ Tree by levels… | CSV of the displayed graph, unfolded from left to right: the context in the first column, then one column per level and per relation (“N2 · Functional exchange”). An element and its first neighbour are on the same row, the next neighbours below. Options: Relation in a separate column (“Relation Nn” + “Nn” columns: fixed number of columns, useful when many relations are checked) and Repeat the parent cells (to filter or build a pivot table; by default, empty cells). “×n” = merged relations, “↺” = occurrence already expanded. Only the displayed nodes are exported (collapsed, hidden and filtered ones excluded). |
| ⬇ Export ▾ › ⇄ Displayed relations… | CSV with one row per displayed edge: source, relation, target, count (merged relations), depth, path from the context. In chain view: source, exchange, target. Both exports go through the “Export columns” window (ID, type, layer, owner, description… can be added for each element column). |
Keyboard shortcuts
| Ctrl + / Ctrl − | Zoom in / out (also Ctrl + mouse wheel). |
| Ctrl W | Fit the view. |
| Ctrl K | 🔍 field of the toolbar: search for a view, an element or a diagram (Enter to open). |
| Esc | Closes the open window or menu. |
| Ctrl/Cmd + click, Shift + click | Multiple selection in the tree. |
| Ctrl V | Pastes a list (text or Excel) under the element selected in the tree. |
🗺 Relation Map
Graph centred on a context element: its neighbours are displayed up to the chosen depth, according to the selected Capella relations (function → component allocation, exchanges, physical links, chains…).
At the bottom of the window, the status bar recalls the context element, the number of nodes and unique elements displayed and the depth; it only appears in the Relation Map. 🎯 Tour of this view picks a context element if there is none yet, to show a graph.
🗂 Views (tabs)
Below the 2nd bar, a tab bar View 1 · View 2 · ＋, as in ▤ Table. Each view keeps the context element, the depth, the layout, the checked types and relations (⚙ Filters), the display options (# Nums, ⌁ Relations, ✂ Names, ⊙ Single, ⬡ Compact, legend), the hidden elements, the nodes collapsed by hand, the zoom and the displayed chain. Every change is recorded in the active view, without a “Save” button; colours stay common to all views.
| Tab | Click: show the view · double-click: rename (an emptied name becomes automatic again) · ✕: close · drag: reorder. Until it is renamed, a view is named after its context, e.g. “Cabin Terminal (LA)”. ⚠: context element missing from the loaded model (choose another one). |
| ＋ ▾ | Copy of the displayed view, empty view (initial settings, same context) or a preset that checks only some relations: 🧱 Structure (breakdowns, deployment), ƒ Functional (sub-functions, allocations, functional exchanges, chains), 🔌 Interfaces (component exchanges, physical links, ports, exchanged items), 🧬 Traceability (realizations between layers, capabilities), ⚡ All. |
| 💾 Save view · 📂 Load view | Saves the displayed view to a .json file; loading opens it in a new tab. |
Views are saved in the 💾 HTML page and in the ⚙ Interface and views file (“🗺 Relation Map” part). They are kept when another model is loaded.
Graph interactions
| Click on a node | Selects the element (the 🔎 Detail panel, when open, follows the selection). |
| Double-click | Makes this node the new context. |
| Right-click | Context menu: 🔎 Detail (panel on the right of the graph: attributes, outgoing and incoming references, requirements, owner, owned elements — clickable links; × to close it), set as context, expand / collapse, hide the element. Also in the tree: 🔎 Detail, set as context. |
| Drag the background · mouse wheel | Pan and zoom. |
Left panel
| Tree | Model elements having at least one relation, at their place in the hierarchy (chains included). Text filter with highlighting. Click = recentres the graph. Multiple selection (Ctrl/Shift), specific to each view. On loading, the layers (Operational Analysis, System Analysis…) are expanded. Takes the whole free height of the panel. Read-only: the Relation Map does not modify the model — neither in the tree and 🔎 Detail (renaming, adding, deleting, moving, pasting a list), nor through the right-click on the graph, nor in the criteria (new, edit or delete a type or a relation criterion). Colours and check boxes can still be set. Arcalyse is a reading and analysis tool. |
Showing a chain in the graph
Click a chain (⚡) in the tree, or the 🗺 button of the ⚡ Chains view: the Relation Map switches to chain view, which shows the complete graph — several inputs, several outputs, branches and loops — arranged in layers according to the chosen layout (→ LR, ↓ TB, ← RL). Blue edging = carried by an actor, green = by the system, grey = unallocated; INPUT / OUTPUT badge; edges labelled with the exchange. A banner summarises the chain; ✕ Leave chain, a double-click on a node or a click in the tree go back to the Relation Map.
Reading the graph
Hovering a node: its direct neighbours stay highlighted, the rest fades. Each node's banner carries the readable name of its type. The Element types panel only lists the types present in the tree, sorted by ARCADIA layer, with their number of elements.
ARCADIA colours
OA Operational Analysis · SA System Analysis · LA Logical Architecture · PA Physical Architecture (PC NODE, PC BEHAVIOR) · EPBS Configuration items.
▤ Table
Table of all the model elements, one per row, opened with the ▤ Table button of the bar. Rows follow the types checked in the sidebar (expanded layers); a double-click on a row opens the detail panel. No global search or layer filter here: each column's Filter… fields replace them.
View tabs
Each tab keeps its own view: checked element types, 🎯 scope (independent of the other views and tabs), displayed columns and their order, filters, widths and sort. A new tab has no type checked: check those to list in the sidebar. + adds a tab (copy of the columns of the displayed view, no type checked), double-click renames it, ✕ closes it. Tabs are saved with the 💾 HTML page and in the ⚙ interface file.
Columns, sort, filters
| 🎯 Scope | Optional tab criterion: rows are limited to the elements contained in chosen elements (package, layer, component, function…). The window shows the chosen elements (✕ to remove), the mode — content at all levels or directly contained only —, the model tree (▶ expand, box to add) and a search by name or type. 🌳 Tree display: with a search, results appear in their containers, greyed when they do not match themselves (they can be checked too). ☰ List display: flat list sorted by name, with the container path, limited to 300 rows (refine the search beyond that). With no chosen element: the whole model. A tab's rows = checked types ∩ scope, then column filters; the counter recalls the scope. |
| ☰ Rows · 🌳 Tree | Tab display. 🌳 Tree: rows are placed under their containers (with a 🎯 scope, starting from the scope elements); ▶ / ▼ in the first column. The ▾ menu next to 🌳 Tree groups the options: Compact (default: each row directly under its closest ancestor that is itself a row, e.g. components and sub-components, without packages) or Greyed containers (intermediate packages and containers shown, greyed and without values); ⊞ Expand all, ⊟ Collapse all, Level 1 · 2 · 3 (containers do not count). The order of elements at the same level follows the sort; ⬇ CSV adds the Level and Path columns. |
| 📋 Copy | Cell selection as in ƒ Functions › ▤ Table: click a cell, click-drag for a rectangle, Ctrl+click to add / remove, Shift+click to extend. Ctrl+C or 📋 Copy: to paste into Excel or Word; a cell with several elements stays a single cell, with one element per line (whatever ≡ Inline / ☰ Stacked). Esc or a click outside the table clears the selection. |
| ✎ Rename | On the header of a path column: ✎ replaces the title with an input field (Enter to confirm, Esc to cancel). |
| ⊞ Columns | Checks the displayed columns, by section: computed columns (Name, ID, Owner and Owned element shown by default; Layer, Type, Human Type), path columns (✏ edit, ✕ delete), XML file attributes and relations. 🔍 field to search a column. |
| Relations | The relations of the model, grouped (breakdown, allocation, exchanges, realization, capabilities, chains), with their number of links. Two boxes per relation: → targets (the elements the row points to, e.g. functions realized by a component) and ← sources (the elements pointing to the row, e.g. the component realizing a function). |
| Headers | Click: sort ▲ ascending, ▼ descending, then no sort (empty cells at the bottom). Drag a header onto another: changes the column order. Right edge: width. Filter… field: filters the column. |
| ≡ Inline / ☰ Stacked | Multi-value cells: comma-separated, or one per line. |
| ⬇ CSV | Exports the displayed columns, for all filtered rows (all pages), in sort order. |
| 💾 Save view · 📂 Load view | Saves the view of the displayed tab to a .json file, or loads it back. |
| ↺ Reset | Goes back to the initial columns, order, widths and sort, with no filter (displayed tab). |
✨ Path column (metachain)
Adds a computed column which, for each element of the table, follows a path of relations in the model and shows what it finds at the end. Examples: the functions allocated to each component, the components connected to a component through its ports, the name of the package owning a requirement.
Building the path: choose the start type (only its rows will be filled), then, at each step, the relation to follow; the type of the next step is deduced automatically. The last step can read a value (Name, ID, attribute); otherwise, the cell shows the names of the reached elements. The choices offered depend on the loaded model:
| Name · ID · Type · Human Type · attributes | Displayed value (end of the path). |
| Owner [Type] | First owning element of the chosen type. |
| Owned element [Type] | Directly contained elements of the chosen type (e.g. a component's ports). |
| Capella relations | Allocation, realization, involvement… in both directions. |
| attribute → Type | Element designated by an attribute (source, target, involved…). |
| ← incoming reference | Elements designating this one (reverse direction). |
| via [Type] → [Type] | Going through an intermediate element (e.g. port → Physical Link → opposite port). |
👁 Live preview: choose a sample element of the start type (🔍 filter, list, Next ▸ to go to the next element whose cell would be filled). The preview shows the elements reached at each step, the step where the path stops if it finds nothing, the final content of the cell and the number of elements for which it will be filled.
+ Add a step · ✕ deletes a step and the following ones · ✏ (⊞ Columns menu) edits an existing column · the preview updates at each change.
🔷 Capella views
View bar (at the top)
📋 Copying cells (all view tables, except matrices): click-drag for a rectangle, Ctrl+click to add / remove a cell, Shift+click to extend; a simple click also selects the cell, unless it or its row already has a click action (link, row opening a detail): the click then keeps its action. A pill appears near the selection: 📋 Copy (also Ctrl+C), Copy the table (headers and visible rows, after filters), ✕. Pasting into Excel or Word: multi-line cells stay a single cell. Esc or a click outside the table clears the selection.
| 🏗 Architecture ▾ | Views are grouped in families: ƒ Functions & exchanges (ƒ Functions, ƒ⇆ functional exchanges, 🟨 OA activities), 🧱 Components & interfaces (SA · System Component, LA · Logical Component, PA · Behavior Exchange, PA · Physical Link, 🧩 Ports), ⚡ Chains & scenarios; then 🚦 Modes & states, 🎯 Capabilities & missions, 🗃 Data & interfaces, 🖧 Deployment & EPBS; Explore: 🗺 Relation Map, 🌳 Tree (Full mode: ▦ Cards). A family opens on its last view; below the toolbar, the family bar leads to the other views of the family. Shared layer: 🧱 has one chip per layer, ƒ and ⚡ a Layer selector; the chosen layer is kept and reused from one family to another (LA chosen in 🧱 → ƒ Functions opens on LA). |
| ✅ Check ▾ | 💚 Health & checks, 🧬 Cross-layer traceability (family: traceability table, ⇶ realization graph), 🧾 Requirements, 🎛 Properties & constraints (family: PVMT properties, 🔒 constraints), ⚖ Version comparison, 🔖 Review status; Advanced (Full mode): 🏷 Exchange categories, 📦 REC / RPL, 📚 Libraries. Each view can still be found on its own through 🔍 search and pinned. |
| 💬 Review & documents ▾ | 💬 Comments (review panel; badge: comments not closed, ⚠ to check), ☑ Checklists & review plans, 📑 Send for review (review files), 📘 Automatic reports, 📐 Dashboard; Full mode: 📜 Scripts. |
| Essential · Full | Buttons on the right of the toolbar (also in ⚙): Essential (default) shows the most used views; Full adds the advanced views. A view missing from the menus remains available through 🔍 search. A setting saved before 3.0 is converted: Expert → Full, Simplified or Custom → Essential. |
| 📌 Pin | In a menu, 📌 places the view as a direct button in the bar (by default: 🏠 Home, 🔲 Capella diagrams, ▤ Table); a second click removes it. |
| 🔍 (Ctrl K) | Search field of the toolbar: type a few letters to find a view, a model element (name, type, layer, identifier; the type and the path are shown) or a diagram (name, acronym, layer, once the .aird is loaded); ↑ ↓ arrows then Enter: the view opens, the element is shown in the details panel, the diagram opens in 🔲 Diagrams. The most relevant section comes first; at most 8 elements and 5 diagrams (refine the search). With no text: 🕘 last elements and diagrams opened this way, then all views (Full-mode ones included) with their pins, ↺ Restore the default bar. The setting is saved with the 💾 HTML page. |
| ⚙ Preferences | Gear wheel on the right of the bar. Menus: Essential or Full (like the toolbar buttons). Toolbar style: Icons and text or Icons only (name on hover; 🧱 marked SA / LA); with Icons and text, the toolbar switches automatically to icons only as long as it does not fit on one line (narrow window). 🎨 Theme…, 💾 auto-save, export format, 🩺 check profile. ⚙ Preferences…: sections ☰ Display, 🎨 Theme (theme previews, 🎨 Adjust colours…), 🔄 File watch (automatic detection and period, check when coming back to the window — saved with the page), 💾 Saving, ⚙ Interface and views (.json export / import), 🩺 Checks and naming, ⬇ Exports (Excel or CSV). |
| ⬇ Excel exports | ⚙ › Table exports: CSV / Excel: every ⬇ CSV button of the views then produces an .xlsx workbook (one sheet, bold frozen header, auto filters, column widths, typed numbers); setting saved with the bar. 📁 File › 📗 Excel workbook of the analyses: one workbook, one sheet per analysis (elements, functions, functional exchanges, components, Component Exchanges, Physical Links, chains, requirements, review statuses, checks, health). No library: the file is written by Arcalyse. |
| ◀ ▶ History | ◀ ▶ buttons at the start of the bar (Alt+← / Alt+→, mouse side buttons): go back to the views opened (🔬 Analyses sub-views included), the elements opened in the detail panel and the diagrams opened, as in a browser; the tooltip names the target step. Right-click on ◀ or ▶: list of the steps (most recent first, current step marked ●), click to go there. The history is cleared when another model is opened. |
| 🩺 Checks profile | ⚙ › 🩺 Checks profile… (or the 🩺 Profile button at the top of each 🩺 Checks tab). For each check of every view: enabled or not (a disabled check disappears from the views and the dashboard, it stays listed at the bottom of the tab to be re-enabled), severity ℹ information (counted apart, outside “points to check” and outside the 💚 score), ⚠ to check or ✖ blocking, whose weight in the 💚 score (ℹ 0, ⚠ 1, ✖ 3 by default) is set at the bottom of the window; 💚 column: cost of each check (weight × rows) and score gain if it were set to ℹ, ⇅ By cost button to see the heaviest checks first — each check has an original severity (· default in the list): ℹ for completeness and good practice (descriptions, naming, Exchange Items, FE → CE and port allocations, realizations between layers, PVMT, requirements, review status…), ✖ for inconsistencies (missing references, broken chains, contradictory port directions, misaligned ports…), ⚠ otherwise; thresholds (minimum description length, name too long, “mostly validated” layer). Saved with the 💾 page, carried over by 📄 Open a project and by ⚙ Interface and views; 💾 Export / 📂 Import .json to share a team's profile. Checks are identified by their title: a profile belongs to one interface language. |
| ♿ Keyboard and screen readers | Every command can be reached with Tab (visible outline) and triggered with Enter or Space: bar buttons, menus, tabs, links of the details panel, table rows. Buttons reduced to a pictogram (“icons only” mode) keep their name for screen readers; dialog boxes keep the focus (Enter = OK, Esc = cancel). The theme follows the light / dark setting of the system on first start (a saved page keeps its theme); animations are reduced when the system asks for it. |
| 💾 Automatic saving | Off by default (⚙ › 💾 Automatic saving). Every 2 to 30 minutes, the page is written to its file (the one used by 💾 / Ctrl+S), only if it has changed (Edge / Chrome). Option Keep the previous version: before each save, the content of the file is copied to a backup file (my-project.backup.html, which opens like a normal page). The browser forgets the chosen files when closed: when reopened, a banner offers to choose them again. |
| 🧭 Explorer | Two tabs: 🌳 Tree and ▦ Cards (detailed below); 🏗 Architecture › Explore menu (Cards: Full mode). The make-up of the model by type is in 🏠 Home › 🧩 Model content (tooltip: description of the type). The type sidebar is only shown in the Explorer and the ▤ Table. |
| 🧭 Explorer › 🌳 Tree | Complete model tree (types checked in the sidebar); own bar: 🔍 search by name or type, 🌳 Tree (results stay in their containers, greyed when they do not match themselves) or ☰ List (flat, sorted by name, with the container path, 300 rows at most), ⊞ Expand all / ⊟ Collapse all, Level 1 · 2 · 3, ⬇ JSON. Click an element: detail panel. |
| 🧭 Explorer › ▦ Cards | Elements grouped by ARCADIA layer, layer filters and search; in pages of 500 cards (⏮ ◀ Prev. · Next ▶ ⏭, at the top and bottom of the list). |
| ▤ Table | Direct button of the bar: paged table with view tabs, attribute, relation and path columns, sort, filters, CSV export (▤ Table tab of this help). |
| ⚡ Chains | Functional chains, operational processes and physical paths: diagrams, tables and exports (⚡ Chains tab). |
| 🔲 Capella diagrams | Capella diagrams of the project (.aird file, next to the .capella) drawn as in Capella by the Arcature viewer: 📂 Open the .aird… (the picker opens in the .capella folder in Edge / Chrome), 📁 Project folder… on the home screen (.capella and .aird loaded together), or drop the .aird (alone or with the .capella) on the window. Explorer on the left: grouped by layer (default), layer › diagram type (OA › OAB…), type or name; collapsible groups (⊞ / ⊟), filter; width adjustable by dragging the separator (double-click: original width). ▣ Map below the explorer (▾ to collapse it, ⇲ to put it back in the diagram, ⇱ to bring it back). ⬇ Export…: several diagrams at once (chosen with ☐ Select…, displayed or all; tables are excluded; warning if the PDF may exceed 40 MB) as sheets — frame and header (layer, acronym, name, type), Capella description and represented element, title block (project, type, layer, content, sources, date, sheet), appendix of represented elements, preview — in the chosen format, then ⬇ Export: PDF (contents, bookmarks, appendices), PNG / SVG ZIP (one folder per layer, one appendix CSV per diagram) or HTML report (sheets collapsible by layer and type). Above the diagram, two rows that do not move from one diagram to another: identity (name, diagram search ▲ ▼, theme, ⬇ Export, ✕; the represented element is in ℹ Info) then tools (📝 Review note and 💬 Layer, chains and paths, filters, zoom, map, layout). Tables, zoom, search (Ctrl+F), minimap, tooltips, filters (ports, labels, exchange categories), chains and paths: only those drawn in the diagram are offered, SVG / PNG / print exports. ℹ Info (or ℹ when hovering a diagram in the explorer): the details panel presents the diagram — type, layer, nature, number of elements, last modification date, description, represented element and displayed elements, grouped by type and clickable. ⧉ Compare (view bar) opens the displayed diagram in the comparison window: a separate window (a single one, reused; for example on another screen) with its own list of diagrams, wheel zoom, drag to pan, ⤢ Fit; clicking an element opens its details in the page. Right-click a diagram in the explorer (or in the open diagram) › ⧉ Show in the comparison window shows another diagram there; the page's diagram does not change. Click an element: its details panel; in the details panel, the Diagrams section opens a diagram where the element is represented, centred on it. Read-only. |
| ƒ⇆ Functional Exchange · 🧱 System / Logical Component · 🔀 Behavior Exchange · 🔌 Physical Link · 🧩 Ports | Interface analysis and consistency checks (🔌 Interfaces & ports tab). |
| 🏗 Architecture › ƒ Functions | Functions layer by layer: hierarchy, table, traceability, metrics, checks, file. |
| 🔬 Analyses | Sub-views split between 🏗 Architecture (modes & states, capabilities, data, deployment) and ✅ Check (health, traceability, requirements, properties, constraints, comparison, review status…); the view keeps its row of tabs (🔬 Analyses tab). |
| 🔄 Watch | Detection of new versions of the .capella file, delta of the changes and update after confirmation. |
Detail panel
Elements are preceded by their Capella icon (variant depending on actor, human, nature, function kind…, drawn by the Arcature viewer): details panel, cards, trees (Explorer and Relation Map), types, review.
A click on a name (almost everywhere) opens the detail panel: Human Type and type description, element description formatted as in Capella (‹/› HTML button: its original code; links to other elements are clickable), 💬 review buttons, attributes, outgoing references, incoming references (what points to this element?), owner and owned elements. Everything is clickable to navigate step by step.
🗂 Panel tabs: the sections are split into 📋 Sheet (description, attributes), 🔗 Links (outgoing and incoming references, owner, owned elements), 🧭 Semantic, 🔲 Diagrams, 🔬 Analyses (requirements, properties, constraints, scenarios, review status, categories, libraries, REC / RPL, deployment) and 💬 Review; ≡ All (default) shows every section in a row (except 🧭 Semantic). The number of sections is shown on each tab; a tab with no section for the element is not offered. The chosen tab is kept from one element to the next (and saved with the 💾 page).
🧭 Semantic: semantic browser like Capella's Semantic Browser, in three columns — ← Referencing elements (elements pointing to it: realizing functions or components, allocating components, chains and capabilities involving it, Parts representing it, diagrams…), Current element (attributes and owned elements, by type) and Referenced elements → (parent, allocated functions, realized elements, incoming / outgoing exchanges through its ports, source and target of an exchange, reference attributes…). Capella's technical links (realizations, allocations, involvements) are resolved into readable categories. Clicking an element makes it the current element (◀ ▶ to go back); the filter field applies to the three columns; ⤢ widens the panel to show the columns side by side.
⧉ Separate window (at the top of the panel, next to ×): the whole detail panel, with its tabs, opens in a separate window (for example on another screen; allow pop-ups) and leaves all the room to the views. It follows the element chosen in the page, and a click in the window (link, 🧭, tab) navigates there; its content scrolls vertically when it overflows. ⧈, or closing the window, brings the panel back into the page.
⚡ Chains
🏗 Architecture › Chains & scenarios menu (📌 for a direct button). ℹ Info (Relation Map view bar, or unfolded card) shows the chain information in the detail panel: type, layer, number of functions (components) and exchanges, inputs, outputs, owners, capabilities involving it, description; 🔎 opens the full detail of the element.
FunctionalChain, OperationalProcess and PhysicalPath are rebuilt as a graph: several inputs, several outputs, branches and loops are kept.
Filters and sub-views
Filter by type and by layer (OA, SA, LA, PA, EPBS), and by content: All / Non-empty / Empty (empty chain = no function or exchange involved). ▦ Diagrams: one card per chain. 🗺 Relation Map view: interactive graph (LR / TB / RL / radial / zigzag layouts, ⬡ Compact, ✂ Names) and injection into the main Relation Map.
Content of a card
- Top-down diagram, Capella style: blue carried by an actor, green carried by the system, grey unallocated; operational processes (OA) in Capella colours: yellow activities, brown arrows; thick border = input or output.
- Involved functions: flow order, type, allocation component, input/output role, number of incoming/outgoing exchanges.
- Involved Functional Exchanges: numbered source → target, Exchange Items, carrying Component Exchange. For a physical path: components, Physical Links and allocated CEs.
- Buttons 🖼 PNG · 📐 SVG · 📋 Copy (paste into Word/PowerPoint) · ⬇ CSV.
💬 Review comments
💬 Comment (open card, Relation Map view bar, ℹ Info) or right-click the header of a card: comment on the chain. Right-click a function of the diagram or graph: the comment is linked to the function and to the chain (“💬 Comment on the chain only” otherwise). In the comment window, the chain's functions are offered in one click (⚡ Link to functions). A commented chain shows 💬 in its header.
🩺 Checks
Third presentation (next to ▦ Diagrams and 🗺 Relation Map view), filtered by the chosen category: empty chains; discontinuous (steps in several unconnected pieces); involvements of a missing element; exchanges with an end outside the chain; references to a missing chain or cyclic references; chains not realized in the lower layer or realizing nothing in the upper layer (only where realizations exist); outside any capability (only if other chains of the layer have one); without description; duplicates; steps carried by unallocated functions; isolated components in a physical path. Each row opens the details of the chain or its 🗺 view. Subject to the 🩺 checks profile; “Chain checks” indicator in the 📐 Dashboard; counted in the 💚 model health, per layer too.
Batch export
Check cards (or All). With no selection, all the displayed chains are exported. Options:
| Frame | Frame and tab at the top left: [FC], [OP] or [PP] + name, band in the layer colour. |
| Title block | Bottom right: project, diagram, type, layer, content, date and file, sheet number. |
| Legend · Description | Colour legend; Capella description of the chain. |
| Appendices | PDF: appendix sheet(s) after each diagram (inputs/outputs, functions, exchanges), paginated. ZIP: one CSV per chain. |
| ×1 · ×2 · ×3 | Resolution of PNG and PDF images. |
📄 PDF: contents page, one sheet per chain (A4, oriented automatically), navigation bookmarks. 🗜 ZIP PNG / ZIP SVG: individual numbered images. 🌐 HTML: tabbed standalone report (Contents with links, vector Diagrams + tables), with built-in search.
🔌 Interfaces & ports
⬇ Enriched CSV (🏗 Architecture: Functional Exchange, Operational Analysis, System / Logical Component, Behavior Exchange, Physical Link, Ports, Links; ƒ Functions and 🔬 Analyses: traceability, capabilities, modes & states, requirements, properties, data & interfaces, constraints): before the download, the “Export columns” window lets you remove columns and, for each column referring to model elements (function, port, exchange, component…), add information inserted right next to it: ID, type, readable type, layer, owner, owner path, description, summary, any Capella attribute (＋ Attribute…) and the ▤ Table ✨ path columns whose start type matches. The choices are kept for each export and saved with the 💾 HTML page and the ⚙ file; ↺ Base columns goes back to the original export.
Interface views of the 🏗 Architecture menu (Functions & exchanges, Components & interfaces, Chains & scenarios sections), from functional to physical: ƒ⇆ Functional Exchange, 🟨 Operational Analysis, 🧱 System Component, 🧱 Logical Component, 🔀 Behavior Exchange, 🔌 Physical Link, 🎬 Scenarios, then 🧩 Ports. Each opens in ◧ Blocks view (Capella-style rendering, navigation from one block to another) and also offers Line / Component (or Function) views, an ▦ N² matrix (click a cell = list of the exchanges) and a 🩺 Checks report. In ƒ⇆, each block shows in small print, at the top, what it belongs to: allocation component or actor (click: its block in the view of its layer) or, failing that, its parent function (click: its block). In the dark theme, a tip recalls that the Blocks view is more readable, and closer to Capella, with the Office 2007 or Light theme. Command bars stay visible at the top when scrolling the view (likewise in ⚡ Chains, ƒ Functions and 🔬 Analyses). As in ƒ Functions, the commands of each bar are framed by category (tabs, views, filters and fields, exports). In the 🔬 Analyses and ƒ Functions › ⛓ Traceability tables, the column names and the filter row also stay visible when scrolling.
HTML exports (🔀 and 🔌): ⬇ HTML = the displayed view; ⬇ HTML (all views) = tabbed report Line view / Component view / Matrix / Checks, filters applied, with search and clickable matrix. The files are standalone and use the colours of the current theme.
Split by layer: 🧱 System Component (SA) and 🧱 Logical Component (LA) for the components and their Component Exchanges; 🔀 Behavior Exchange for the PA-layer Component Exchanges between Behavior Physical Components; 🔌 Physical Link for the links between Node Physical Components.
ƒ⇆ Functional Exchange
Exchanges between functions (all layers), same organisation as 🧱 Logical Component, with a layer filter (OA, SA, LA, PA) and an Allocation filter as in ƒ Functions (🧩 System, 👤 Actors, ∅ Unallocated; double-click: only this one) and the All allocation targets list of the layer (actors, then system and subsystems as a tree, sub-components included; in OA: operational entities and actors); in the exchange views, an exchange is kept if either of its two functions matches:
| ◧ Blocks view | Default view. Each function drawn as in Capella: rounded box with the function name, green if allocated to the system, blue if allocated to an actor, grey if unallocated (or parent function); input pins (green) on the left and output pins (orange) on the right with the port name; next to each pin, the exchange and the remote function (several exchanges on the same pin: listed one below the other, centred on the pin). Click on the remote function: shows its block (changing page and relaxing filters if needed), ↩ Back returns to the starting block; click on a block title: detail panel. Pale pin: unconnected port; dotted pin: exchange connected directly to the function, without port (normal for OA activities). “with ports or exchanges” option (unchecked by default) to hide parent functions. |
| ≡ Line view | Source function, output pin ▶ and port → exchange → input pin ▶ and port, target function; Exchange Items (▤), Component Exchanges allocating it (🔀), chains (⚡). |
| ▣ Function view | One card per function: received (←) and sent (→) exchanges. |
| ▦ Matrix | Function × function (row = source, column = target), limited to 100 functions to stay responsive (the most connected); filter by layer or function to see the others. |
| 🩺 Checks | Orphan ports, exchanges without Exchange Item, leaf functions without exchange, parent functions carrying ports, exchanges without port (except OA), LA / PA exchanges not allocated to a Component Exchange. |
The Line, Function and Blocks views are paged by 100 (◀ ▶) to stay responsive on models with several thousand functions; CSV and HTML exports cover the whole filtered result.
🎬 Scenarios
Sequence diagrams of Capella scenarios — ES (Exchange Scenario), FS (Functional Scenario), OES / OAS in OA, IS (Interface Scenario) — redrawn from the .capella file alone. On the left, the list sorted by layer then by capability (layer, type filters, search); on the right, the diagram: lifelines (light blue = actor, blue = component, green = function, grey = entity), messages with, for ES, their exchange context in braces, activation bars, functions (green rectangles), states (light grey ellipses) and modes (dark grey), combined fragments (ALT, OPT, LOOP, PAR…) with their guards, “ref” references to another scenario (click: open it). Click an element: its details. Lifeline names stay visible at the top when scrolling; scrolling with the bars, the mouse wheel (Shift + wheel: horizontal) or by click-dragging the diagram background. Zoom − / +, PNG / SVG exports and image copy. 🩺 Checks: empty scenarios, messages without exchange, lifelines without represented element, scenarios outside any capability, missing references. The detail panel of a scenario or a capability also offers 🎬 to open the diagram.
The order of events is that of the model; spacing is computed (the layout drawn in Capella is in the .aird file, which is not read): the content is faithful, not the pixel position.
🟨 Operational Analysis
Operational activities (OA layer) and their interactions, in the spirit of Capella OAIB diagrams. ◧ Blocks view (default): yellow rounded blocks with the OA pictogram, incoming interactions on the left and outgoing on the right (click a remote activity: go to its block), carrying entity or actor in small print at the top of the block (click: its details). Also ≡ Line view, ▣ Activity view, ▦ Matrix activity × activity and 🩺 Checks. Filters: activity, interaction or Exchange Item, allocation (🏢 Entities, 👤 Actors, unallocated, or a specific entity / actor). CSV exports of the interactions and HTML reports.
🧱 System Component · 🧱 Logical Component
Two identical views (same code, same colours): 🧱 System Component for the SA layer, 🧱 Logical Component for the LA layer; components with their Component Ports and Component Exchanges, same logic as ƒ⇆ Functional Exchange:
| ◧ Blocks view | Default view. Each component drawn as in Capella: blue for the system, light blue for an actor; number of allocated functions (ƒ) and sub-components (⧉). Ports according to their orientation: UNSET, > IN (chevron pointing inwards, on the left), > OUT (pointing outwards, on the right), INOUT; INOUT and UNSET go on the less loaded side. Next to each port: the exchange, its direction (from / to / ⇄) and the remote component (several exchanges on the same port: listed one below the other, centred on the port); click on the remote component: shows its block, ↩ Back. Pale port: not connected. |
| ▣ Component view | One card per component: sent (→), received (←), bidirectional (⇄) or unoriented exchanges, with ports, exchange and remote component (click: go to its card). |
| ƒ Allocated functions | “ƒ n functions ▾” under a block's name expands the list of allocated functions (numbered, with a filter beyond 12 and a scrolling area for long lists); click a function: shows its block in ƒ⇆ Functional Exchange. Also in 🔀 Behavior Exchange and 🔌 Physical Link. |
| ≡ Line view · ▦ Matrix | One Component Exchange per row; component × component matrix (100 components at most). |
| 🩺 Checks | Orphan ports, connected ports without orientation, inconsistent orientations, leaf components without port or without allocated function. |
| Filters | Component, exchange, Nature (🧩 System, 👤 Actors; double-click: only these), All components (one component and its sub-components), “with ports” (unchecked by default: check it to hide components without port). Pages of 100. |
🔀 Behavior Exchange (formerly Component Exchange)
Scope: PA-layer Component Exchanges whose two ends are Behavior Physical Components (no Node). The number kept out of the model total is recalled at the top of the view.
Scope: exchanges between Physical Components Behavior, and between a Behavior and an actor (most often a node) connected to it; these actors appear with only their relevant ports.
◧ Blocks view (default): Physical Components Behavior drawn as in 🧱 Logical Component (blue = system, light blue = actor; UNSET / IN / OUT / INOUT ports; clickable exchanges and remote components; expandable allocated functions). The other views (Line, Component, Matrix, Checks) are unchanged.
Orientation of ComponentPorts: UNSET (attribute absent) · IN · OUT · ⇄ INOUT. The actual direction is deduced from the two ports:
| → Oriented / ← Reversed | An IN or OUT port sets the direction (source → target or the reverse). |
| ⇄ Bidirectional | INOUT port(s) with no other constraint. |
| ? Unoriented | Two UNSET ports: unknown direction (dotted line). |
| ⚠ Inconsistent | OUT→OUT or IN→IN — except for a DELEGATION, where the direction is deduced from the parent / child nesting. |
Each exchange shows its kind (ASSEMBLY, DELEGATION, FLOW), its allocated FEs (ƒ), its Exchange Items (▤) and its carrying Physical Links (🔌). Checks: CE without FE, orphan ports, inconsistent orientations, unoriented CEs, PA-layer CEs not allocated to a physical link.
🔌 Physical Link
Links between physical components (and actors) through their PhysicalPorts. For each link: the allocated Component Exchanges (⇢) and, on each port, an n CP badge showing the allocated Component Ports. In the title blocks (here as in 🔀 Component Exchange), long lists are folded after 4 items: click +N others to expand them. Filters with / without CE. Checks: links without CE, physical ports not connected or without Component Port, unallocated PA-layer CEs.
◧ Blocks view (default): each node (Physical Component Node) drawn as in Capella: yellow for a system node, light blue for an actor node; physical ports as yellow squares; next to each port, the Physical Link (⇄) and the remote node, clickable to go to its block. Nature filters (🖥 Nodes, 👤 Actors) and sub-components.
🧩 Ports
Function Port ↔ Component Port ↔ Physical Port traceability, rebuilt from the PortAllocations and ComponentPortAllocations.
| ≡ Traceability | One row per Function Port / Component Port with FE, CE, physical ports and links. Layer, text, “incomplete chains” filters. CSV export. |
| ▣ By component | Physical ports → carried Component Ports; Component Ports ← allocated Function Ports. |
| 🩺 Checks | Unallocated ports at each level; inconsistent direction between function port and component port; FE ↔ CE alignment (the FE ports must be allocated to the ports of the CE carrying it) and CE ↔ PL (same with the physical ports). Delegations are followed step by step. |
ƒ Functions and 🔬 Analyses
Results are kept in memory; ↻ Recompute (at the end of each analysis bar) refreshes them. Analyses open from the 🏗 Architecture and ✅ Check menus, 🔍 Ctrl+K or the family bar: no more tab bar at the top of the analyses (3.0). Checks are only computed when the 🩺 Checks tab is opened.
Long tables and lists: shown by pages of 200 rows (‹ › bar at the top and the bottom: previous / next page, page choice, Show all) — analysis tables, 🧩 Ports, 🧬 Traceability, 🔗 Links, lists of the detail panel; an active column filter shows every row so that it applies to all of them. CSV / Excel exports always contain everything.
Tables: under each header, a Filter… field per column (several words: all required; !word: exclude); the number of displayed rows is shown above, with ✕ clear. Dragging the right edge of a header sets the column width (double-click: automatic width). Filters and widths are kept when the view is redrawn. A table wider than the view has a horizontal scroll bar stuck to the bottom of the screen while it is visible (also Shift + mouse wheel).
Cross-cutting analyses computed from what the open model contains: a topic absent from the model (no state machine, no capabilities…) is simply reported as empty, and the checks only cover the practices actually used. The tabs and commands of each sub-view are framed by category (views, filters, exports), as in ƒ Functions.
ƒ Functions (first tab of 🔬 Analyses)
OA activities and SA / LA / PA functions, layer by layer, with their descriptions highlighted.
Allocation filter (🌳 Hierarchy and ▤ Table): 🧩 System 👤 Actors ∅ Unallocated, with the number of functions of each kind. Click = show / hide, double-click = only this kind (double-click again: show all). Each function carries an edging of the corresponding colour (double edging if allocated both to the system and to an actor); in the tree, parent functions kept for the hierarchy are faded. “Allocation kind” column in the table and exports.
Allocation target (list next to the filter): a specific actor, or the system and its subsystems as an indented tree (white-box LA / PA layers), with the number of functions; a subsystem includes its sub-components. ✕ removes the filter. In white box, the “Subsystem” column gives the path of the enclosing components (full path on hover).
| 🌳 Hierarchy | Numbered tree (1, 1.1, 1.2…) with badges: allocation, exchanges ⇄, realizes ⬆ / realized by ⬇, missing description. “Descriptions” option to read them in the tree. Click a function: sheet on the right (path, description, summary, sub-functions, allocation, ports, incoming and outgoing exchanges, chains, capabilities, states, traceability tree upwards and downwards). The sheet links navigate from one function or layer to another. The ⋮ separator between the tree and the sheet can be dragged to adjust the widths (double-click: default widths). |
| ▤ Table | One row per function, indented (Flat option without indentation); resizable columns (header edge), sortable (click), filterable by text (field under the header) or by values as in Excel (▼: sort, search, check boxes with counts; a multi-value column is split) and hideable (⊞ Columns); full descriptions as an option; quick filters; number of functions shown / total. Cell selection: click-drag, Ctrl+click, Shift+click, then 📋 Copy or Ctrl+C (paste into Excel or Word; Esc clears). CSV and 🌐 HTML exports (current columns, widths, filters and sort). |
| ⛓ Traceability | OA → SA → LA → PA paths going through the chosen layer, with descriptions; ∅ = break. |
| 📊 Metrics | ◂ collapses a layer (it moves to the left of the labels, ▸ to expand it); only expanded layers are exported: 🌐 HTML of the indicator table, high-definition 🖼 PNG or 📋 image copy for a presentation. Layer comparison: count, leaves, depth, description, allocation, exchange and traceability rates, coverage by chains and capabilities; breakdown by level; most connected functions. |
| ✍ Name quality | Offline: verb first (infinitive in French, base form in English — built-in list of about 1,000 verbs), -ing form or action noun first, vague verbs, capital letter, spaces, punctuation, length, minority language in the layer. “Name quality” column and “Name to review” filter in the table, indicator in the metrics. ⚙ Naming rules: accepted domain verbs and false verbs, kept in the 💾 HTML page. |
| 🩺 Checks | Name quality (above), missing or too short descriptions, TODO/TBD/NOT DONE markers, duplicates, missing or multiple allocations or allocations on a parent function, leaves without exchange, exchanges on parent functions, unused ports, traceability breaks. |
| 📄 Functional file | HTML report: one tab per layer, one numbered section per function (description, allocation, inputs / outputs, realizations, chains, capabilities), plus metrics and checks. Printable. |
🧬 Cross-layer traceability
Uses all the …Realization links (functions, components, exchanges, ports, capabilities, chains, scenarios, states, data, configuration items) and, as an option, the transition TransfoLinks.
| ▦ Coverage | By category and OA→SA→LA→PA→EPBS transition: ▼ realized (upper elements realized by the lower layer) and ▲ realizing (lower elements realizing the upper layer), in % with colour code. Click a cell: untraced elements. |
| ⛓ Paths | One row per traceability path, one column per layer (e.g. OA activity → SA function → LA function → PA function). |
| 🔗 Links | Filterable list of all the realization links. |
| Leaf functions | Ignores parent functions (containers), which are generally not realized. |
⇶ Cross-layer links
Graphical view of the realizations between layers: one column per layer (OA, SA, LA, PA, EPBS), an arrow from the realizing element to the realized element (upper layer). 🔬 Analyses menu, right-click on an element (⇶ Cross-layer links) or button in a chain's ℹ Info.
| ◎ From an element | Search for a starting element (or suggestions: the chains, capabilities and functions with the most links). Realizations upwards and downwards: what it realizes going up and what realizes it going down; All links, step by step: also the neighbours of the elements found. |
| ▦ A whole category | All links between elements of a category (functions, chains, capabilities, components, exchanges…), 400 elements at most. |
| Chain functions | Under each chain (dotted frame), its functions and their own links: you can see which LA functions realize which SA functions of a realized chain. |
| Mouse | Hover: the element's links are highlighted; click: detail; double-click: start again from this element; right-click: 💬 Review comment. − / +: zoom. |
| Exports | ⬇ SVG, 🖼 PNG, ⬇ CSV of the links; 📑 To package: adds the drawing to the open review package (redrawn on the loaded model at each export of the package). |
🎯 Capabilities & missions
Operational capabilities, system capabilities, Capability Realizations (LA/PA) and missions: functions, chains, involved actors/components (including via Part for older versions), scenarios, inclusions, missions exploiting them, realizations between layers.
| ▣ Cards | One card per capability or mission, grouped by layer. |
| ▦ Matrix | Capabilities × actors/components, × functions, × chains, or missions × capabilities. |
| 🩺 Checks | Capabilities without function or chain, without actor, without scenario, not realized lower down, not exploited by a mission; empty missions; leaf functions outside any capability. |
🚦 Modes & states
| ◈ State machines | By component: diagram (blue states, yellow modes, ● initial, ◉ final, ◆ choice; transitions labelled trigger [guard] / effect), tables of states (entry / do / exit, available functions) and transitions. |
| ▦ Functions × states | Availability of functions in each state or mode (availableInStates). |
| 🩺 Checks | Regions without initial state, unreachable states, dead-end states, transitions without trigger or guard, functions never available. |
🔄 Watching the .capella file (updates)
📁 File › 🔄 File watch detects that a new version of the loaded file has been saved (by Capella) and offers to update the display. Nothing is applied without your confirmation.
| Detection | Automatic, to be checked in the watch menu or in ⚙ Preferences › 🔄 File watch, setting saved with the page (off by default; every 10 s, 30 s, 1 min or 5 min), when coming back to the window, or manual (🔍 Check now). A notification shows the number of elements ➕ added, ➖ deleted, ✎ modified, ↪ moved; a 🔄 button then appears next to 📁 File, its badge shows the number of pending saves. |
| Delta | 🔍 View the delta: filterable list, property-by-property detail (before / after), summary by layer, CSV export, or opening in ⚖ Version comparison. |
| Several saves | The cumulated delta (displayed model → last save) is the one that will be applied; each detected save is also listed with its own delta (compared with the previous one). If the file goes back to the displayed version, the proposal disappears. |
| After the update | The current view is kept. 🕘 Session update history (delta of each); ⚖ comparison with the version before the last update or with the opening version. |
| From another file | 📁 File › 🔄 Load a model update: choose the new file; the same delta is shown before confirmation, and this file becomes the watched one. If fewer than 50% of the elements are shared with the displayed model, a warning says it may not be the same project, and the update asks for confirmation. |
| Diagrams (.aird) | After an update, if an .aird is loaded: opened with direct access (📁 project folder, 📂 Open the .aird under Edge / Chrome), it is re-read from disk and taken over if it changed. Otherwise, a window offers 📂 Choose the up-to-date .aird, keeping the current diagrams or removing them (with the number of elements shown by the diagrams that no longer exist). With a .capella alone, nothing is asked. Opening another model removes the diagrams of the previous one (unless they are loaded with it: project folder, .capella + .aird dropped together). |
| Browser | Edge / Chrome: open the model through 📁 File › 🔷 Open or by drag and drop for direct access (automatic re-read). Otherwise (other browser, saved HTML page), the change is reported when possible and the file must be selected again (📂). |
⚖ Version comparison
Two tabs: 🔷 Model (the report below) and 🔲 Diagrams, which compares the loaded .aird with a reference .aird: kept automatically when the .aird is re-read or replaced after a 🔄 update (the old one becomes the reference), or chosen with 📂 Load a reference .aird. Diagrams matched by identifier: ➕ new, ➖ deleted, ✎ renamed, 🧩 content changed (model elements added to or removed from the diagram, listed), 🎨 layout / style only (positions, sizes, styles not detailed: Capella often rewrites them). Even without a reference: ⚠ elements missing from the model (the diagram shows elements deleted from the .capella) and 🔷 affected by the model (elements added, deleted or modified according to the 🔷 Model tab). Filters, clickable ▸ detail, 🔲 open the diagram, ⬇ CSV; “Diagrams — …” indicators in 📐 Dashboard. Opening another model clears the reference.
Load another version of the same model (by default the old one; ⇄ to swap). Elements are matched by identifier and the changes sorted into 8 categories:
| ➕ Creation · ➖ Deletion | With the container; contained elements (ports of a deleted function…) are attached: “with 2 contained elements”. |
| ✏ Renaming | Old name → new name. |
| 📝 Description | Description or summary modified (differences in formatting only are ignored). |
| ⚙ Properties | Attributes (kind, nature, orientation…), property values. |
| 🔗 Links | References added (+) or removed (−): allocations, realizations, Exchange Items… |
| ↪ Move · 🔁 Type | Change of owner; change of the element type. |
| Levels | Summary (counts by category, layer and family) · Simple (one sentence per change) · Detailed (each property before → after) · Full (+ identifier, technical type, path). |
| Presets | 📰 Release notes (Simple) · 🔍 Review (Detailed) · 🛠 Audit (Full, technical elements not grouped). |
| Filters | Categories, layers, type families, search; grouping by category, layer, family or parent element. Attach technical elements to their element (checked by default): allocations, realizations, involvements… appear as 🔗 links of the element concerned rather than as separate elements. |
| Excluding a row | Uncheck it: it stays visible (struck through) but disappears from the copy and exports; ↺ include all again. |
| 📋 Copy | Copies exactly what is displayed, in the chosen format: formatted (Word, Outlook, Teams, OneNote: headings, lists, tables), plain text, Excel table (one row per change) or Markdown. |
| Exports | ⬇ CSV, ⬇ standalone HTML, 🖨 Print (or PDF). |
🧾 Requirements
Requirements Viewpoint requirements (identifier, text, attributes, incoming / outgoing Capella relations and relations between requirements) and basic Capella requirements (SystemUserRequirement…, RequirementsTrace traces). Filters: family, type, attribute value, linked to the model or not.
| 📋 List | ID, name, folder, text, attributes, linked elements (with their layer) and linked requirements. |
| ▦ Coverage | Number of elements linked to each requirement, by ARCADIA layer. |
| 🩺 Checks | Requirements linked to no element, without text, without identifier, duplicate identifiers, relations to a missing element; leaf functions and components without requirement (only in the layers where other elements have some). |
🎛 Properties (PVMT)
Properties of the PVMT extensions (domains, groups, properties and units) and simple properties set on the elements. ○ = default value never entered.
| ▦ Grid by group | One row per element, one column per group property; total of the numeric properties. |
| Σ Summary | By property: sum, minimum, maximum and average of the numeric values, or breakdown of the values. |
| 📖 Definitions | Defined groups, classes and architectures they apply to, filled-in and missing elements. |
| 🩺 Checks | Elements targeted by a group but not filled in, values left at default, groups without a link to their definition. |
🗃 Data & interfaces
| 📦 Exchange Items | Mechanism, elements (name: type [cardinality]), Functional / Component Exchanges carrying them, interfaces allocating them. |
| 🔌 Interfaces | Allocated Exchange Items, ports providing or requiring them, components using or implementing them. |
| 🧱 Classes & types | Classes (typed properties), enumerations (literals), physical quantities (unit), inheritance and uses; predefined types as an option. |
| 🩺 Checks | Exchange Items not carried or without content, Functional Exchanges without Exchange Item, empty or unused interfaces, Exchange Items of an FE missing from the interfaces of the carrying CE's ports, types never used. |
🔒 Constraints
All the constraints: role (guard, pre / post-condition), expression (text links are replaced by the name of the cited element), language, constrained elements, owner. Checks: empty constraints or without expression, missing cited elements, without constrained element, duplicates.
An element's detail panel also shows its linked requirements, its properties and its constraints. The corresponding indicators are in the 📐 Dashboard catalogue.
🖧 Deployment & EPBS
| 🖧 Deployment | Each physical node (PhysicalComponent of nature NODE) with the behaviours (nature BEHAVIOR) it hosts through PartDeploymentLink, the number of functions carried and its physical links; undeployed behaviours at the bottom; ⬇ CSV. |
| 🧰 EPBS | Tree of Configuration Items (nature COTS, software, hardware, interface, NDI, system…) and the physical components or links they realize (PhysicalArtifactRealization); breakdown per nature. |
| 🩺 Checks | Undeployed behaviours, nodes without behaviour (only if the model practises deployment), exchanges between behaviours deployed on nodes that no physical link connects, multiple deployments, nodes not realized by a Configuration Item, empty Configuration Items, realizations of a missing element, elements realized by several items, items without nature. |
The details panel of a physical component shows where it is deployed, what it hosts and the Configuration Item realizing it. ⚡ Chains › 🩺 also checks the continuity of physical paths (involved link whose ends are not on the neighbouring components).
🧩 SysML v2
Arcalyse also reads a SysML v2 model in textual notation: a .sysml file, a .kpar archive or a folder of .sysml files (📁 Project folder, or several .sysml files dropped together: names resolve from one file to another). Reading is done by the Arcature SysML v2 reader (sister project, Apache 2.0), embedded in the page, offline and read-only.
| What works | Each SysML metaclass has its own icon (drawn for Arcalyse: one glyph per nature — part, port, action, state, requirement, package… —, family colour, solid definition, light usage, dashed reference usage). The model is converted into elements like a .capella: 🌳 Tree, ▦ Cards, ▤ Table (attribute columns: declaration, qualified name, keyword, family, visibility, direction, multiplicity, value, file, line; references typedBy, specializes, source, target…), detail panel (outgoing and incoming references, 🧩 SysML v2 section: declaration, clickable links, diagnostics of the element, text excerpt), 🔍 Ctrl+K, 🗺 Relation Map (“SysML — …” relations: typing, composition, connection, specialization, allocation, satisfy… shown by default, the others to tick), 💬 Review, 💾 saved page, 📜 scripting API (analysis.sysml()). |
| 🏗 Architecture › 🧩 SysML v2 | 🧩 Elements (chips by family Structure / Behaviour / Requirements & cases / Organization, list of metaclasses, search), 🔗 Links (by relation: source, target, via), 🩺 Diagnostics (reader errors and warnings with file: line, rule, message, element; taken up by 💚 Health & checks and the 🩺 profile — errors ✖, warnings ⚠), 📄 Files (text of each file, line numbers). ⬇ CSV on each tab. |
| 🔲 Diagrams | SysML v2 has no diagram file: the reader computes views from the text and lays them out automatically — GV general view (definitions, usages, compartments, specialization, typing, compositions, satisfy), IV interconnection (nested parts, ports, connections), STV states (transitions, triggers), AFV action flow. List on the left: one collapsible group per kind (▾ / ▸, icon per kind), filter, width adjustable by dragging the separator. Open view on the right as 🖼 Visual — SVG drawing in the Arcalyse theme; clicking a shape or a link opens the element in the detail panel; hand: drag to pan the view, Ctrl + wheel or − ⊡ + to zoom; ▣ Map below the explorer as for a Capella diagram (collapsible ▾ / ▸; ⇲ puts it in the view, where the ▣ Map button shows or hides it, ⇱ brings it back below the explorer; frame of the displayed part, click or drag to go there); 📝 Note and 💬 Layer: 💬 Review notes placed on the view as on a Capella diagram (drag the note or right-click an element; linked to elements, movable, found again from the comment list) — or ≡ Text (coloured textual rendering: «keywords», names, types, compartments, links “a → b [kind]”; Ctrl + wheel or − ⊡ + for the text size); ⬇ SVG (standalone document) and ⬇ Text. An element's views are in the 🔲 tab of its detail panel, and in 🔍 Ctrl+K with the diagrams. |
| 🏠 Home | SysML v2: n elements · errors · warnings (click: the view) and Views: n (click: 🔲 Diagrams) pills; the Capella-specific views (functions, exchanges, chains, scenarios, requirements…) are marked as having no data. |
| Not covered | No writing (nothing is modified) nor manual layout of the views (laid out automatically at each computation, no filters), no 🔄 file tracking nor ⚖ version comparison, no ARCADIA layer (everything is “Transverse”). The standard library is only known by its names (ISQ::mass…). A page saved with a SysML model reopens the elements but neither the 🧩 view nor the computed views (reread the .sysml). |
📦 REC / RPL
Capella's reusable elements: a REC is a template (a set of model elements), an RPL a replica instantiated from that REC (suffix, compliancy BLACK_BOX / CONSTRAINT_REUSE / INHERITANCY_REUSE). Each element of a replica keeps a link to its origin in the REC.
| 🧬 Replicas | Each RPL with its REC, suffix, compliancy, number of elements and differences: missing (REC elements without counterpart), added (no origin in the REC), different types, renamed outside the “REC name + suffix” rule, missing targets; filter by REC; ⬇ CSV. |
| 📦 REC | Each template: default compliancy, elements, replicas (✔ compliant or number of differences). |
| ⇄ Comparison | A replica against its REC, element by element, with the state of each (✔, missing, added, different type, renamed). Also reachable through ⇄ in the tables and the details panel. |
| 🩺 Checks | Incomplete replicas, enriched replicas, different types, names outside the rule, links to a missing element, missing REC, REC without replica, duplicate REC, elements belonging to several replicas. |
The details panel of an element shows the REC or replica it belongs to; that of a catalogue element, its content. “REC / RPL — …” indicators in the 📐 Dashboard.
📚 Libraries
A model can reference elements of another .capella file (Capella library): the reference reads platform:/resource/Project/File.capella#id and the libraries used are declared (LibraryReference). Arcalyse reads a single file: without the library, those targets are “missing”.
| 📚 Libraries | Each referenced library: project, declared or not, number of references and of targeted elements, loaded or not. 📂 Load… opens the library's .capella file (several at once); with 📁 Project folder opened on the parent folder (model and libraries side by side), the referenced libraries load by themselves. A loaded library is not saved in the page. |
| 🔗 References | Each external reference: source element, attribute, library, target (📚 name and type of the targeted element when the library is loaded). Same display in the details panel (attributes and “External references” section). |
| 🩺 Checks | References to a library not loaded, targets missing from a loaded library (different version), declared libraries without reference, references to an undeclared library. |
🏷 Exchange categories
The categories Capella lets you set on exchanges: ExchangeCategory (Functional Exchanges), ComponentExchangeCategory (Component Exchanges), PhysicalLinkCategory (Physical Links). They also filter ƒ⇆ Functional Exchange, 🔀 Behavior Exchange and 🔌 Physical Link (“🏷 All categories” list, shown only if the model has some), and the details panel of an exchange lists its categories (and that of a category, its exchanges).
| 🏷 Categories | Each category: layer, kind, number and list of exchanges; ▸ opens the flow view filtered on the category. |
| ⇆ Exchanges | Share of categorized exchanges per kind and layer, then each exchange with its categories (filter categorized / without category). |
| 🩺 Checks | Exchanges without category (in the kinds and layers where categories are already used), empty categories, referencing a missing exchange, duplicates, exchanges in several categories. |
💚 Health & checks
Single entry point for checks (✅ Check › 💚 Health & checks): you also get there from each view — the 🩺 n failing check(s) → 💚 pill of the family bars, or the 💚 Health & checks button at the top of each 🩺 Checks tab — the list then being filtered on that view. View chips (All or one view, with the number of failing checks), Failing only box (checked: checks that have rows, most frequent first) and, on each row, Open ↗: the view opens on its 🩺 Checks tab, with the check's section expanded.
A score from 0 to 100 built on all 🩺 checks of every view, with the 🩺 checks profile (disabled checks ignored; weights ℹ 0, ⚠ 1, ✖ 3): 100 × e−(Σ weight × rows ÷ number of named elements): 0.1 anomaly per element ≈ 90, 0.36 ≈ 70. Only ⚠ and ✖ checks weigh: completeness and good-practice checks are ℹ by default (counted “for information”, to be raised in the 🩺 profile if the team requires them); a check carried by two views is counted once. Levels: Good (≥ 90), Watch (≥ 70), Rework. Score per ARCADIA layer for the checks that can be computed per layer (functions, functional exchanges, components).
| 🏠 Card | On the home: score, level, points to check and blocking points, bars per layer, difference with the previous version and curve of the last versions. Above 30,000 elements, the computation waits for a click. ✕ Hide removes the card from the home (⚙ Arrange › Hidden to show it again); in the sub-view, the ▦ Per view tab lets you hide the checks of a view from the score (“Counted” box). Unticking a layer (box in front of OA, SA, LA, PA, EPBS, also in the sub-view) excludes it from the overall score: its per-layer check rows and its elements no longer count, checks without a layer count in proportion to the remaining elements (useful for a layer not yet worked on); the setting is kept with the project. |
| 📋 Checks × layers | Each check with its view, severity, number of rows overall and per layer; ⬇ CSV. |
| ▦ Per view | Checks, checks without anomaly, points and blocking points of each view. |
| 📈 History | One row per model version opened in the project (same file: entry updated), kept with the 💾 page; “Model health — …” indicators in the 📐 Dashboard. |
🔖 Review status
Capella's native review fields: Status (a literal of the project's ProgressStatus enumeration: DRAFT, TO BE REVIEWED, TO BE DISCUSSED, REWORK NECESSARY, REVIEWED…) and Review (free text), carried by any element. Statuses are sorted into classes from their name: draft, pending, validated, to rework.
| 📋 List | Elements with a status or a Capella comment: layer, type, status, comment; filters by layer, status (or class), type, presence of a comment; search. The 💬 button creates a 💬 Review comment on the element (the number of existing comments is shown). |
| ▦ Breakdown | Number of elements per status and layer, then per element type and class. |
| 🩺 Checks | Elements to rework, pending review, drafts in a mostly validated layer, Capella comment without status, to rework without a comment in 💬 Review, unresolved status reference. |
The details panel shows the status and comment of the element (🔖 see all = the list filtered on that status); the status column of the ▤ Table shows the literal name. “Review status — …” indicators in the 📐 Dashboard catalogue.
📐 Dashboard (separate tab, next to 🔬 Analyses)
Build your own dashboards from all the computed indicators (≈ 130 on a complete model): model, functions (by layer and layer comparison, allocation, allocation targets, subsystems, naming), chains, Component Exchanges, Physical Links, ports, traceability, capabilities, modes & states, requirements, properties, data & interfaces, constraints, checks. A sample dashboard is created the first time it is displayed.
| ✏ Edit | Switches to editing: ＋ Add an item opens a panel on the left (catalogue with search, all categories expanded, “Layout” and “Diagrams and views” first) and immediately places the new item in the grid, dotted, where it is drawn live while you set it up (title, representation, size…); ✔ Add to the grid or Cancel. ＋ when hovering an item to insert one before it, “＋ Add an item” tile at the end of the page; ⚙ configures an existing item in the same panel (no more window); ⧉ duplicate, ✕ remove. The view keeps its scroll position during the changes. |
| Diagrams and views | 🔲 Capella diagram: chosen from the list of the open .aird, its image is saved with the dashboard (↻ Update to take it again). ⇶ Cross-layer links: starting element or category, redrawn on the loaded model (also from the view, 📐 To dashboard button). Outside editing, a click opens the diagram or the view. |
| Charts | Figure, gauge (green ≥ 90%, orange ≥ 50%, red otherwise), horizontal or vertical bars, donut, stacked or grouped bars, table, free text (titles, comments). Number of categories displayed (the rest is grouped as “Others”) and sort can be set. |
| Layout | Drag an item by its title to move it; bottom-right corner to resize it (snapped to the 3, 4 or 6 column grid). |
| Several pages | One tab per dashboard page; the ＋ tab adds an empty page. Double-click a tab (or ✎ on the active tab) to rename it. While editing: ⧉ Duplicate, ✨ Example, 🗑 Delete. Dashboards are kept in the 💾 HTML page. |
| Printing | 🖨 Print in A4 portrait (default) or landscape format: items are redrawn at page size, in light colours, with a header (name, model, date). “Save as PDF” in the print window to get a PDF. |
| Exports | 🌐 Standalone HTML (as displayed); ⬇ / ⬆ JSON to reuse a layout on another model. |
💬 Review — comments on the model and diagrams
💬 Review & documents › 💬 Comments opens the review panel, docked on the right: the view narrows to make room for it (nothing is hidden). If the detail panel is open too, 🔎 Properties / 💬 Review tabs switch between them; opening an element's details shows 🔎 Properties. ⧉ detaches the panel into a separate window, ✕ closes it. Both panels share the same width, adjustable by dragging their left edge (↔ cursor; double-click: default width); it is saved with the page. Its badge counts open comments; ⚠ n flags comments to check after a model update.
Commenting
| Detail panel | 💬 Comment (the element), 💬 the name, 💬 the description below the element name; a 💬 appears when hovering each attribute. The 💬 Review comments section lists those concerning the element. |
| Right-click | On an element in the views (blocks, cards, tables, lists, detail panel links, diagrams): comment on the element, its name or its description, see its comments. |
| 🔲 Capella Diagrams | 📝 Review note (next to the diagram search): drag it onto the diagram (dropped on an element, it is linked to it) or click to place it in the centre; right-click in the diagram, on an element or in an empty area › 📝 Review note here (on an element: linked to the element, its name or its description). A comment created in a diagram is always attached to the diagram (layer note). Notes form a layer independent of the .aird (💬 Layer button): they follow the zoom, move by their header, resize by the corner, collapse to a dot (▁). Linking: draw a line from the note's ● handle to an element (to an already linked element: it is unlinked), or 🔗 then click the elements (Esc to finish); linked elements are framed and connected to the note, the ● dot in the middle of a line unlinks it. Outside notes, diagram elements remain clickable; the layer is hidden with 💬 Layer. |
| ✚ New | In the 💬 Review panel: comment on the element shown in the detail panel, or general comment; elements can be added in the editor (search by name or type). |
Fields
Only the text is required. Optional: title, severity (Information, Minor, Major, Blocking), category (Question, Remark, Error, Improvement), status (Open, In progress, Fixed to be checked, Validated, Rejected), author (pre-filled from ⚙ Settings › Your name), due date, assignees (participants declared in ⚙ Settings, or added in the editor), tags. The creation date is recorded automatically, as well as the commented part of each element (whole element, name, description or another attribute). The offered fields are chosen in ⚙ Settings. Each comment can receive replies. Ctrl+Enter saves.
Panel tabs
| 💬 Comments | Search, filters (status, severity, person, scope: open diagram, detail panel element, overdue, assigned to me), sorting. Click a card: full text, replies, status, ✔ Validate, 🗑. ➜ goes to the diagram note or to the element. |
| 🔁 Check | After a new load or a 🔄 model update: open comments whose commented value has changed (before / now) or whose element has disappeared, and comments “Fixed, to be checked”. ✔ Validate closes the comment (date and checker recorded); ↻ Keep open takes the current version as the new reference. |
| 📄 Report | Status × severity summary; standalone, printable 📄 HTML report (grouped by status, severity, assignee or element, optional replies, status of each comment against the loaded model); ⬇ CSV. |
| ⚙ Settings | Your name, participants, offered fields, display (diagram layer, closed notes, 💬 mark of commented elements in the views), 🗑 Delete all. |
| 💾 Review ▾ · ⧉ | At the top of the panel: ⬇ Export and 📂 Import / merge the comments (.json, or reviewed page .html from “have comments reviewed” or from a 📑 review package), 📤 Have comments reviewed, with the number of unsaved comments. 🎓 starts the guided tour of the panel (also ❓ Help ▾ › 💬 Review tour). ⧉ opens the panel in a separate window (on another screen, for example; allow pop-ups) linked to the page: closing it (or ⧈) brings it back into the page. |
Saving
Comments are saved in the page (💾 Save, Ctrl+S). 💾 Review ▾ › ⬇ Export (.json) keeps them outside the page (backup, sending); 📂 Import / merge combines the reviews of several reviewers (new comments added, most recent version kept for the others, replies combined). Comments remain when another model is opened.
📤 Have comments reviewed
To have a chaptered document reviewed (descriptions, diagrams, free text), see 🏠 Home › 📑 Review packages instead.
💾 Review ▾ › 📤 Have comments reviewed (or 📄 Report, or 🏠 Home › review plan › 📤 Have the scope's comments reviewed): choose the comments (filtered list, not closed, all, plan scope, then boxes), a title, instructions and a feedback date; options: existing answers, description of the targeted elements, commented diagrams with their notes (.aird loaded). A standalone HTML page is created: it opens in any browser, offline, without Arcalyse.
The reviewer enters their name, answers each comment (opinion: 👍 agree, 👎 disagree, ❓ question, 💡 proposal, ✔ fix verified, and text) and can add comments (general or on an element of the review). 💾 Save the page with my answers downloads the completed page: send it back to the author or pass it to the next reviewer (answers accumulate); ⬇ Export my answers (.json) gives a short version.
Import back: 💾 Review ▾ › 📂 Import / merge accepts the reviewed page (.html) or the .json: answers are added to the comments (opinion shown), new comments are added and linked to the elements of the loaded model; the same file imported twice adds nothing.
Right model?
Each comment and each export records the Capella project identifier (root Project element of the .capella: unique identifier created with the project, kept from one version to the next). On import, the review is compared with the loaded model: same project identifier → direct import; otherwise, share of the commented elements found in the model (identifiers that are also unique and stable). With fewer than 5 commented elements, this share is not enough: the import is direct only if all are found, otherwise a window compares both sides (file, project, elements found) and offers Import anyway or Cancel. A copied project keeps its element identifiers: it is recognised as a copy. Comments from another project are marked ⧉ other project and are not checked (Loaded project scope in the list to hide them).
📜 Scripts — reading and analysis macros
💬 Review & documents › 📜 Scripts (Full mode; or Alt+4, or 🔍 search “Scripts”) opens a console below the views: JavaScript scripts browse and analyse the displayed model through an API, like Catia Magic macros or Python4Capella. The API is Arcature's (same names), limited to reading: Arcalyse never modifies the model; it adds analysis, the results of every Arcalyse analysis.
| Run | Pick an example in the list or write a script, then Ctrl+Enter (▶ Run). ■ Stop interrupts an endless loop. Elements shown in the output are links (click: detail panel); tables export as ⬇ CSV; files produced by out.file are offered for download. model.selection holds the element opened in the detail panel. |
| API | model (elements(filter), find, count, findByPath, layer('LA'), root, selection, diagrams), element (name, type, layer, description, owner, children(), descendants(), attributes(), isA(), references(), referencedBy(), links('allocation', 'in'), diagrams), metamodel (Capella types and inheritance), out (print, table, csv, file, progress), ui (await ui.ask, confirm, choose, readCsv). Filter: a type name (subtypes included), a function, or { type, exactType, layer, name, technical, where }. Full reference: docs/api/arcalyse.d.ts and docs/api/LISEZMOI.md. |
analysis | With await: functions(), chains(), traceability(), capabilities(), states(), health() (💚 score), requirements(), properties(), data(), constraints(), status(), categories(), rec(), libraries(), scenarios(), ports(), functionalExchanges(), componentExchanges(), physicalLinks(), deployment(), checks(view) (🩺 checks, profile applied), nameQuality(name). The results are those of the views; every object that designates an element carries element. |
| Library | 💾 saves the script in the project (kept in the 💾 HTML page, reloaded by 📄 Open a work project), 📂 imports .js files, ⬇ exports the displayed script, 🗑 removes it. 📁 Shared folder (Chrome / Edge): a folder of scripts (next to the model, on a network share) whose .js files appear in the list; 💾 rewrites the file; the folder is found again at the next opening. |
| Isolation | The script runs in an isolated worker, on a snapshot of the model: no page, no file, no network (fetch removed). A script received from a colleague can neither send the model elsewhere nor touch the page. An error gives the line of the script (click: the editor goes there). |
| Recipes | Number of elements: out.print(model.count()) · per layer: out.table(['OA','SA','LA','PA','EPBS'].map(layer => ({ layer, n: model.count({ layer }) }))) · per type: out.table(model.types()) · functions without description: model.elements({ type: 'AbstractFunction', where: f => !f.description }) · health score: (await analysis.health()).score. More recipes in docs/api/LISEZMOI.md. |
| Arcature | A script that only uses model, metamodel, out and ui runs as is in Arcature (which can also modify the model). model.tool is 'Arcalyse' or 'Arcature'. |
🏠 Project home
View shown when a model or a project is opened (🏠 Home button, at the far left of the bar). Everything entered there is saved in the page (💾).
🏠 Project
At the top, the project header: name, file, elements per layer, status pills — Model loaded, Diagrams (.aird loaded, click: 🔲 Diagrams; or “no .aird — Add…”), Libraries (click: table of the referenced libraries with their status — loaded, loaded with missing targets, file missing, never used — and “Load the file…”, “See the references”) — then the views without data in this model, removed from the menus in Essential mode. Next, What do you want to do?: six tasks that each open the right view (diagrams, 💚 health, 💬 review, ⚖ comparison, ▤ table, 📘 reports; ✕ hides the section, ⚙ Arrange the cards shows it again). Then six cards: 🔷 Project (Capella project, file, Capella version read from the file, loaded diagrams and their number per layer — click the name: 🔲 Capella Diagrams —, number of elements, last model update and 🔄 to load one); editable 📝 project sheet (purpose, phase / milestone, version, owner, team, notes); shortcuts to checklists and review plans (progress, ⧉: separate window); model content per layer (tooltip of a type: its description); 💚 health; 💬 review status.
⚙ Arrange the cards (like a dashboard, on a single page): drag a card by ⠿ onto another to place it before, ⇔ switches its width between 1 and 2 columns, ✕ hides it (＋ to show it again), ↺ restores the default layout. The layout is saved in the page.
☑ Checklists & review plans
On the left, the ☑ New checklist list: “Empty (to fill in)” (the cursor is placed on the first item; Enter adds the next item) or a template (Model quality, OA, SA, LA, PA reviews); the 📋 New review plan list: empty plan or with the checkpoints of a template; 📂 Import… a checklist saved as .json. From 🏠 Project, ✚ Quick checklist also creates an empty list. Sections and items to check, with owner and 💬 finding; Enter adds an item; ↑ ↓ 🗑 on hover. Drag and drop from the 📎 palette (on the right: search for diagrams and elements): onto an item, it is linked to it (clickable chip: diagram or detail panel); onto “✚ Item”, it creates a linked item.
✚ Review plan… offers a review plan format:
| Header | Review purpose, milestone / type (SRR, PDR, internal review…), date, place, moderator, status (in preparation, in progress, completed), decision (accepted, with reservations, rejected, postponed), participants and roles, reference documents. |
| Scope | Reviewed diagrams and elements (dragged from 📎); number of open review comments on this scope; 📤 Have the scope's comments reviewed (page to send to reviewers, see 💬 Review); 📑 Review package of the scope (see below). |
| Sections | 1. Entry criteria · 2. Checkpoints (taken from the chosen template: OA, SA, LA, PA, quality) · 3. Exit criteria · 4. Actions and decisions (owner, due date). |
⬇ HTML: printable document (with, for a plan, the review comments on the scope); 💾 .json / 📂 Import…: reuse a checklist or a plan in another project; ⧉ (header) duplicate (boxes unchecked).
Two spaces in the same view: 🏠 Home (🏠 Project; 🏠 button of the toolbar) and 💬 Review & documents (☑ Checklists & review plans, 📑 Send for review, 📘 Automatic reports; 💬 Review & documents menu, with a 💬 Comments button that opens the review panel). 📑 Send for review lists the review packages; 📘 Automatic reports the standard outlines, your templates and the produced reports — same editor, same exports. In the 💬 Review panel, 📤 Send for review sends comments to reviewers (stand-alone HTML page).
📑 Review packages
A review package gathers, chapter by chapter, what other people must review and comment: description of a capability or a functional chain, its diagrams, other diagrams in sub-chapters, elements with their description, free text. 📑 New package, then:
| ✚ Chapter | Chapter with a free title. Or drag an element (capability, functional chain, function…) from the 📎 palette or the views onto the bottom area: the chapter takes its name, its description and the diagrams whose represented element it is. An element dropped on a chapter title is associated with it (Description box: its description under the title). |
| In a chapter | Drop a diagram (Description box: its Capella documentation; Represented elements box: table under the figure) or an element (with its description); ✚ Text: free text (context, question to the reviewers). On ✚ Sub-chapter: the diagram or the element becomes a sub-chapter. |
| § To chapter · ¶ To block | Converts a block into a numbered chapter (a text gives its title from its first line; an element becomes the associated element; a diagram is placed in the new chapter) or a chapter into an unnumbered block (its content moves up one level). Feedback already received stays attached. |
| 🔗 Model text | A free text can become the name, the description or the name and description of an element or diagram, read again from the model at each export (they follow the .capella updates): drag the element or diagram onto the block header, or 🔗 Link… (search by name), or right-click. When the free text already is the name or description of an element, the 🔗 link to …? badge suggests it. The original free text is kept aside (↺ Original text); ¶ Freeze replaces it with the current model text, editable. Chapter associated with an element: 🔗 next to the element = linked title (element name). Feedback on a model text goes into 💬 Review on the name or description of the element. |
| Right-click | On a block or chapter (header, margins): turn into model text, freeze, show name / description, associate an element, linked title, open the element or diagram, insert a text or chapter after, convert, duplicate, copy the text, move up / down, out / in, remove. On the 🧭 Outline: go to chapter, collapse / expand all. In a text field, the browser menu is kept (copy, paste, spelling); Ctrl+right-click opens Arcalyse's there. |
| ↑ ↓ ⇤ ⇥ 🗑 | Move up, move down, move out of the chapter (upper level), move into the previous chapter (lower level), remove. ▾ collapses a chapter. Chapters are numbered (1, 1.1, 1.1.1…). |
📤 HTML page to comment: standalone page (offline, without Arcalyse) with table of contents, numbered chapters and figures (click to enlarge). The reviewer enters their name, selects a passage if needed then clicks 💬 on the right of a title, description, diagram or text (type: remark, question, error, proposal, agree; severity), ticks Reviewed on the chapters read, then 💾 Save the page (to send back, or to pass to the next reviewer) or ⬇ Feedback .json.
📝 Word (.docx): same content in a Word document (headings 1 to 4, figures as images with captions). Reviewers comment it with Word comments (Review › New Comment) and can edit the text with Track Changes.
📥 Re-import… (several files at once; also from 💬 Review › 📂 Import): saved page, .json or commented .docx. Each feedback item is attached to its block (💬 n chip, click to read it; Show all feedback in the package order); in Word, a comment is attached to the chapter, description or diagram where it is placed, with the commented passage; tracked changes become proposals. The same file imported twice adds nothing; a package missing from the project is recreated from the page. 💬 Send to the Review creates a 💬 Review comment per feedback item (target: the element or its description) to track its handling.
The table of a diagram's represented elements is ticked by default: in the page, each row has its own 💬 (table collapsed under the figure, to expand); in Word, a comment placed on a row is attached to the element. Unnamed involvements (function involved in a chain…) are replaced by the involved element. Feedback sent to 💬 Review targets that element.
Also available from 💬 Review (📑 button in the header, 💾 Review ▾ › 📑 Review packages…, 📄 Report). ⧉ (list or header) opens a package in a separate window; ▸ collapses the 📎 palette (◂ 📎 reopens it). Re-imported feedback is immediately sent to 💬 Review, with the “📑 Review package” tag and the package title; the comment card shows 📑 package › chapter (click: open the package).
📘 Automatic reports (📘 Reports button of the bar, next to 📐 Dashboard, or frame at the top of the package list): creates a package following a standard systems-engineering outline, filled from the model, then fully editable and exportable like any package (HTML page to comment, Word). 📘 System technical specification (black box), two outlines: outline 1: purpose, scope (context, system, mission and capability diagrams), documents, terminology, functional analysis (missions, capabilities, chains), functional requirements per system function (description, external inputs and outputs, diagrams), external interfaces (exchanges with the actors, environment, inputs, outputs), operational requirements (scenarios, modes), dependability, constraints, verification; outline 2: introduction (purpose, documents, terminology), system presentation (purpose, mission and objectives; physical / organic and functional context; stakeholders), technical requirements (functional per system function, performance, functional and physical interfaces, operational and scenarios, constraints, validation and certification). 📗 System design file (white box): logical architecture (components, external and internal flows, exchanged items), LA functional chains (diagrams and ⇶ cross-layer links), sequences, physical architecture (components, external and internal physical interfaces, LA → PA allocation), physical flows, constituents and derived requirements per constituent (allocated functions, including deployed ones, physical links). Parts the model does not provide are “[To be written — …]” texts; diagrams are chosen by layer and type (open the .aird first). 📘 SSS — System/Subsystem Specification and 📗 SSDD — System/Subsystem Design Description: MIL-STD-498 outlines (DIDs DI-IPSC-81431 and DI-IPSC-81432), with the DID numbering kept. A window asks for the scope: the system (SA System) or a subsystem (SA, LA or PA component searched by name); the inside of the scope (sub-components, deployed components), its functions, its exchanges with the outside and its counterparts are derived from it. SSS: states and modes, one section per capability (otherwise per function), one external interface per counterpart (component and functional exchanges), internal interfaces, data, computer resources (PA: nodes, behaviors, physical links), constraints, and requirement sections found by keywords (safety, security, environment, quality, personnel, training, logistics, packaging…). SSDD: design decisions, components (sub-components, allocated functions, realizations, deployment), concept of execution (chains, scenarios, modes), one section per interface (exchanged items, allocated functional exchanges, carrying physical links). Requirement tables show identifier, text, priority and verification (requirement attribute or PVMT property whose name contains “priorit” or “verif / qualif / method”), linked elements. What the model does not contain is a “[To be completed — …]” prompt recalling what the DID expects.
The left list and the 📎 palette can be resized by dragging their edge (double-click: default width); the width is saved in the page and applies to all tabs. 🧭 Outline (under the package list): navigation pane of the open package, numbered chapters; a click goes to the chapter (expanding it); ⊟ / ⊞ collapse or expand all chapters. Collapsing or expanding a chapter no longer goes back to the top of the document. The exported HTML page also shows its table of contents in a left pane on large screens.
👁 Preview (package or template header): rendering of the report as the HTML page exports it, shown over the application without downloading anything; 📄 Reading / 💬 With comments switch, 🖨 Print, ⬇ HTML page, ⧉ to open it in a separate window (on another screen, for example: clicking 👁 Preview again refreshes it there), ✕ or Esc to close. For a 🧩 template, the preview shows the report it would produce on the loaded model, without creating it.
💬 Comments in the HTML page (package header): unticked, the exported HTML page is a plain report to read and print (no 💬, reviewer name or saving). Unticked by default for automatic reports. The Word file keeps its Word comments; its table of contents is made of links to the chapters.
🧩 My report templates
To create your own automatic report: ✚ New template (📘 Automatic reports frame) creates a template pre-filled with an example to adapt. A template is edited like a package (chapters, texts, dropped diagrams and elements), with two more kinds of blocks:
| 🔁 “For each” loop | Chapter repeated for each element found: type (functions, components, physical nodes, actors, chains, capabilities, missions, exchanges, physical links, exchanged items, diagrams), layer, filter (allocated to the system, to an actor, leaves, linked to the element of the enclosing loop for nested loops: functions of a component, functions of a chain, exchanges of a function…), name contains, maximum number. Chapter title: {nom}, {type}, {couche} (also in texts). Description box: the element's description under the title. |
| ⚙ Automatic content | Computed for the loop element: description, diagrams whose represented element it is, diagrams by layer and type (SAB, LAB, ES…), incoming / outgoing functional exchanges (with the outside only or all), allocated (and deployed) functions, physical links, chains involving the function, element table (type, layer, filter), 🔗 cross-layer links. |
▶ Generate the report (template header, or ▶ in “🧩 My templates”) creates an ordinary package, editable and exportable; the template stays intact and can be reused after an update of the Capella model. 💾 .json / 📂 Import: reuse a template in another project.
▤ Element table block (automatic reports): editable title, ▾ View / edit to remove (✕) or add (drag and drop) elements; on export, one row per element (name, type, description; or exchange, source, target, exchanged items), each row can be commented in the page and in Word.
From a review plan, 📑 Review package of the scope creates a package with one chapter per element or diagram of the scope.
⧉ Separate windows and drag and drop from the views
The ⧉ of a checklist, a plan (left list, 🏠 Project card) or a 📑 package opens it in its own window (on another screen, for example; allow pop-ups), linked to the page: changes show on both sides. The view shows a reminder (⧉ Show the window, ⧈ Bring back here).
Meanwhile, drag into that window: a diagram from the 🔲 Capella Diagrams list, a card or a tree row from 🧭 Explorer, a chain from ⚡ Chains (list of the Relation Map view or header of a card). On a checklist: onto an item, onto “✚ Item” or onto the scope of a plan. Within the view itself, the 📎 palette on the right is the source.
🧪 Use case — reviewing a Capella model
- Load the
.capella file (drag and drop). Look at 🏠 Home › 🧩 Model content to see what the model is made of.
- Browse with 🧭 Explorer (▦ Cards and 🌳 Tree); open the detail panel to follow incoming and outgoing references.
- Analyse a neighbourhood in 🗺 Relation Map: choose a component in the tree, set depth, layout and criteria.
- Review the chains in ⚡ Chains: inputs/outputs, unallocated functions (grey), exchanges without carrying CE.
- Check the interfaces: 🧱 System / Logical Component (Capella-style blocks with ports, orphan or unoriented ports), 🔀 Behavior Exchange (PA), ƒ⇆ Functional Exchange (functions as Capella-style blocks with pins, orphan ports, exchanges without Exchange Item), 🔌 Physical Link (links without CE), 🧩 Ports (FE ↔ CE ↔ PL alignment).
- Measure maturity in 🔬 Analyses: traceability coverage between layers, uncovered capabilities, incomplete state machines; compare with the previous version of the model (⚖ 📰 Release notes or 🔍 Review report, to copy into Word or Outlook) to prepare a review.
- Produce a deliverable: PDF of the chains with appendices, CSV of the checks and tables, HTML reports; or 💾 HTML page to share the whole analysis.