VS Code

The ArcLang extension turns VS Code into a model workbench: the text of the model on one side, its diagrams, tree and properties on the other, and the same compiler behind both. Write ArcLang, or click; the file is the same.

Install it from the Visual Studio Marketplace (VS Code) or from Open VSX (VSCodium, Cursor, Gitpod, Theia), or take the .vsix attached to each release. It needs the arclang compiler, 4.5.0 or later, on the PATH or named by the setting arclang.binary; the command ArcLang: Install or locate the arclang compiler helps. The features marked 4.6 below (semantic git, CI/CD and the simulation setup) need the 4.6 extension and compiler.

In the editor

The language server (arclang lsp) gives the problems with their rule, the outline, completion from the metamodel, hover documentation, go to definition, rename through the lossless source editor, and formatting that touches whitespace only.

The workbench

ArcLang: Open the workbench opens, beside the source, the viewer of the compiler's own diagrams (the Arcadia views, named diagrams, capabilities, data, modes and states, scenarios) with what a Capella user expects around it:

• a palette per view: create actors, entities, activities, functions, components, nodes, ports, classes, states and modes; connect them by interactions, functional and component exchanges, physical links, transitions and messages, with two clicks and a name (ports are declared when the ends have none); drag a function or a component onto another to move it;
• a properties form typed by the metamodel: texts, quantities, enumerations, references, lists; Rename keeps the identity of the element;
• a semantic browser: owner, incoming, outgoing, owned, each a step away;
• the findings and the production gate of the model as it is, each finding a click from its element and its line.

The model tree in the ArcLang side bar lists the elements by layer and ownership, with Go to source, Rename, Delete and Ask @arclang.

Every gesture becomes requests to arclang edit: the compiler refuses the ones that would leave a model that does not compile, and an accepted one lands in the editor as a single change that Undo takes back. Comments, order and layout of the text are kept. The selection follows from the text cursor to the views and back.

Draw and arrange

The sheet edits the way draw.io does, but on the model: every gesture is checked by the compiler and is one undo.

• Reconnect an exchange by dragging one of its ends to another box or port (valid targets are highlighted and port directions kept), reverse it, rename in place by double-click or F2, Move to... for any element, ports included.
• Copy, cut, paste, duplicate (⌘C ⌘X ⌘V ⌘D): paste where you point or beside the original; several elements pasted together keep the exchanges and traces between them; the ArcLang source of the selection goes to the system clipboard, so it pastes into another model's workbench with fresh ids.
• Align, distribute, same size, smart guides, a 10-unit grid, arrow keys, band selection, bends on an exchange, eight resize handles. Arrows attach: an end snaps to a port within reach or to the box under the pointer, and exchanges are re-routed orthogonally around the other boxes.
• One history. ⌘Z and ⌘⇧Z undo and redo moves, resizes and bends as well as model edits, in the order they were made, on any keyboard layout.
• A context menu on boxes, ports, exchanges, selections and the sheet, a floating toolbar by the selection, and ? for the list of shortcuts.

The arrangement is kept in <model>.layout.json, which is versioned with the model and merged by Semantic git.

Layers, groups and arrangement

• Layers made of tags (⇧⌘L, or the Layers button): Default (what carries no tag) and one layer per tag, the first tag of an element being its layer, with counts. The eye hides a layer: its boxes and their lines are neither drawn nor exported (SVG, PNG, copy as image, PowerPoint). The padlock locks it (no move, resize, reconnection, delete or rename on the canvas; the properties stay editable). Rows can be dragged to draw a layer above the others. Move the selection to a layer sets the tag through arclang edit, with one undo.
• Groups (⌘G): sibling boxes in a frame that moves, aligns and stacks as one, nests, has an optional label and collapses to one box. A group is only in the layout file; the model is not changed. Group into a new component... (or function, node, state) creates the container in the model and moves the selection into it.
• Stacking like draw.io: Bring to front (⇧⌘F), Send to back (⇧⌘B), Bring forward, Send backward. Lock an element with ⌘L.

Tables and matrices

Tables are computed by the compiler on every change of the model, each in an editor tab of its own that sits beside a diagram: Requirement coverage (with the computed verdict of each test case and the gate's blockers), the Traceability matrix, the Allocation matrix, the N² interfaces, the ICD (one row per exchange) and Elements (any kind, the columns picked among its attributes). Open them from the model tree, ArcLang: Open a table of the model or ArcLang: New table....

A filter bar takes words, column:text, column=text, column!=text, is:gap and -term; there is a filter per column, Only gaps, sortable columns, and rows drawn only where the view is, so thousands scroll smoothly. Cells link to elements. Text, priority, protocol and other attributes are edited in the cell through arclang edit, checked by the compiler, with one undo. In a matrix a click on an empty cell creates a trace of the chosen kind and a click on a filled one removes it after asking. Export CSV or Excel (.xlsx, written by the compiler), copy as TSV and an HTML table that pastes as a table into Excel, PowerPoint or Word, or Save as table... to add the table declaration to the model. The command-line counterpart is arclang table.

Impact analysis

Impact analysis opens in its own tab and answers "what does a change to this element reach, and why?" from arclang impact: the distance, the shortest path (LC-BATT --satisfies--> REQ-R --verified by--> TC-R), a category and a severity of each impacted element, as a graph by rings, a table with a clickable path, and filters. A what-if (delete, change an attribute, retype, move) is applied to a copy and compiled: the gate before and after, the constraints that flip, the latency budgets, the coverage, the stale verdicts; then Apply the change (one undo) or Discard. Impact of my changes compares with HEAD, main or any revision. The impacted elements are outlined on the diagrams, and the report exports to Markdown, HTML or Excel. See Review and change for what the compiler computes.

Semantic git (4.6)

• Compare ▾ draws the diagrams with the changes against HEAD, a branch, a tag or a baseline marked: added, modified, removed ghosted, moved and renamed, with counters on the layer tabs and a panel of changes by layer with the gate before and after.
• History... lists the commits of an element and draws the model at one of them beside the current one.
• Create baseline..., Compare with a baseline..., Verify a baseline....
• Install the semantic merge driver, and the Resolve conflicts view with Accept ours, Accept theirs and Edit.

All of it is the compiler's: see Semantic git. It is not in the browser build, which has no git.

CI/CD (4.6)

ArcLang: Configure CI previews and writes the pipeline for GitHub Actions, GitLab CI, Azure DevOps or Jenkins with arclang ci init, and a status bar item shows the latest GitHub Actions run of the branch, read through the gh CLI with its own login. The generated pipelines have not been run against the providers by us. See CI/CD.

Simulation (4.6)

A Simulation item in the status bar says whether OpenModelica was found (OpenModelica (Docker), (local), needs setup), runs arclang verify with a cancellable progress, and opens a setup checklist with one-click fixes (Docker, the image, the Modelica library, Modex) instead of a raw error. Export Modelica and Open the Modelica drawing are in its menu. See Simulation. Simulation needs the desktop extension.

New, open, import and save

New model... (blank, an Arcadia skeleton, or an example), New layer... (the levels and sections the model lacks), New diagram..., Open a diagram... and Open model... are in the command palette, the model tree's title bar and the workbench toolbar.

Import is in the title bar of the model view (the cloud icon), in the Explorer's context menu and in File ▾ › Import a model.... One quick pick asks what you import:

The import report says what was imported and what was left out and why, whether the written model compiles, or the refusal with the .rejected.arc the compiler kept.

Save in the toolbar shows a ● while the model has unsaved changes; ⌘S saves through VS Code without touching the canvas history, and a .sysml is written back as SysML v2. File ▾ › Save as... writes SysML v2, Capella (.capella, .aird, .afm), ReqIF (the requirements) or a copy as .arc, through arclang export. The Capella and SysML v2 pages say what each carries.

Themes and slides

arclang.diagram.theme sets the color theme of every diagram: a preset (arclang-default, capella-classic, colorblind-safe, print-grayscale, high-contrast, monochrome-document), the id of a team theme kept in .arclang/themes/*.json of the workspace (so it is versioned with the model), one of your own (Edit or create a diagram color theme...), or the path of an arclang-theme.json file. A theme that breaks a color rule is refused, with the reasons, and the default is drawn. The drawing follows VS Code's dark and high-contrast themes; exports stay light.

Diagrams leave as SVG, PNG, an image on the clipboard that pastes into PowerPoint, Keynote or Word, or a PowerPoint file: Export the diagrams to PowerPoint (.pptx)... writes one 16:9 slide per diagram you pick, with its title, the drawing as a picture and speaker notes that list the elements shown. Hidden layers are left out of every export.

With AI

The AI proposes; the compiler decides. Every proposed change is a list of arclang edit requests run on a copy of the model first, with the compiler's refusals sent back to the AI, and nothing changes until you click Apply (one undoable edit).

Choose the AI with ArcLang: Configure AI or the status bar item. arclang.ai.provider is one of eight: vscode-lm (the default: any model VS Code offers, GitHub Copilot included, nothing to configure), anthropic, openai, azure-openai, mistral, google, ollama (local: nothing leaves the machine), and openai-compatible (any base URL: LM Studio, vLLM, llama.cpp, LiteLLM). off sends nothing, by any feature. Keys are never settings: they go to VS Code's secret storage. The first request to a cloud provider asks first and says what is sent and where, and the ArcLang AI output logs every request, never a key.

• Ask AI on a selection (⌘I, the ✦ of the floating toolbar, or Ask AI... in the menu): select boxes, lines or lines of text and ask. The AI gets the selection's source, relationships, neighbors, findings and the gate state, and the preview shows the explanation, the edits, the diff, the changed boxes marked on the diagram and the findings the change would add. Apply, Open diff, Refine... or Reject.

• Impact-driven suggestions: a ✦ AI tab shows what an edit broke (removed traces, requirements no longer satisfied, new findings and blockers) and the AI proposes one to three architecture changes, each compiled before it is shown. By default the consequences are shown and the AI runs on a click (arclang.ai.suggestOnEdit). @arclang in the chat view answers with the compiler at hand, on the configured provider (by default the language models VS Code provides):

• /model writes or extends a model; the answer is compiled before it is shown and corrected when the compiler refuses it.

• /fix repairs the errors and findings of the open model, minimally.

• /explain, /review, /transition explain, review against the gate, plan the next Arcadia step.

• /agent changes the open model step by step: it reads the elements and their ids through the compiler, applies precise edits you confirm one gesture at a time, retries what the compiler refuses, and ends with a check and the gate.

Agent mode and other assistants get the compiler as tools: #arclangModel, #arclangEdit, #arclangCheck, #arclangGate, #arclangMetamodel, #arclangRules, #arclangImpact, #arclangTransitionPlan, #arclangSet, #arclangRename. The extension also offers the ArcLang MCP server to agent mode when it is installed.

SysML v2 files

A .sysml file opens in the same workbench: the compiler imports the text for the tree and the views, and writes an edited model back through its SysML v2 export (the Arcadia profile, ids kept). The text is then the compiler's rendering of it; comments and layout of the original are not kept, unlike .arc files. ArcLang: Import converts a .sysml into a .arc file when you prefer to continue in ArcLang. See SysML v2 for what the import and the export carry.

In the browser

The playground is the compiler in WebAssembly with the workbench on top. VS Code for the Web goes further: a whole VS Code workbench in the page, running this extension, with a workspace of sample models that lives in your browser (memory, saved to IndexedDB) and never reaches our servers. The only text that leaves the page is what you send to an AI you chose.

It answers the model commands of the extension: the workbench and its editing gestures, checks, the formatter, the metamodel and the rules, the Arcadia transitions, and SysML v2 export and import. It does not do, and says so when asked: the production gate as a command, tables, impact analysis, the semantic diff, the other exports (ReqIF, C headers and the rest), the Capella import, PowerPoint export, simulation (there is no OpenModelica or Docker in a browser) and git and CI (there is no git in a browser, so no compare, history, baseline, merge driver or pipeline setup). Use the desktop extension for those. The AI chat works with the hosted provider or your own key; the VS Code language models of the desktop (Copilot) are not available in a browser.

Security

The extension runs only the arclang binary, with argument lists and no shell; the executable and the MCP command are user settings that a repository cannot change. Nothing runs on the files of a workspace VS Code does not trust. Diagrams are drawn in a webview under a content security policy that allows only the extension's own scripts, no network. Language model tools read only files of the workspace or open in the editor, and the editing tools ask for confirmation. The extension has no telemetry. It makes a network request only for a feature you use that needs one: the AI provider you chose (the first request to a cloud provider asks first, and the provider, its address and the consent are user settings a repository cannot change), a SysML v2 API server you name, or the GitHub CLI you have logged in for the CI status.

Behind it: the compiler's workbench API

The views and the agent use two commands anyone can script:

• arclang workbench model.arc prints, as one JSON document, the diagrams as the viewer mounts them, the explorer document, every element with its typed attributes and the id the compiler gives it, the findings named after their rule, and the gate.
• arclang edit model.arc --request '{"op": "add", "keyword": "function", "name": "Filter", "container": "LC-001"}' applies one edit written as JSON (set, unset, rename, add, add_raw, remove, move, add_trace, remove_trace, wrap_fragment) under the guarantees of the scripted edits.

The playground runs the same code compiled to WebAssembly.