Command-line reference

$ arclang check --help
Usage: arclang check [OPTIONS] <INPUT>

Arguments:
  <INPUT>
          

Options:
      --lint
          

      --safety
          

      --json
          Print the findings as JSON, each named after its rule (see `arclang rules`)

      --format <FORMAT>
          text (default) or sarif: the diagnostics as a SARIF 2.1.0 log

          Possible values:
          - text
          - sarif: SARIF 2.1.0, for GitHub code scanning and Azure DevOps

  -v, --verbose
          

  -c, --config <CONFIG>
          

      --as <PATH>
          The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file

  -h, --help
          Print help (see a summary with '-h')

$ arclang gate --help
Production-readiness gate: PASS/FAIL verdict against what an industrial design review requires (requirements coverage, HARA/ASIL consistency, timing budgets, ICD completeness)

Usage: arclang gate [OPTIONS] <INPUT>

Arguments:
  <INPUT>
          

Options:
      --standard <STANDARD>
          [default: iso26262]
          [possible values: iso26262, do178c, iec61508]

      --format <FORMAT>
          text (default) or sarif: the gate's findings as a SARIF 2.1.0 log

          Possible values:
          - text
          - sarif: SARIF 2.1.0, for GitHub code scanning and Azure DevOps

  -v, --verbose
          

  -c, --config <CONFIG>
          

      --as <PATH>
          The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file

  -h, --help
          Print help (see a summary with '-h')

$ arclang diagram --help
Usage: arclang diagram [OPTIONS] --output <OUTPUT> <INPUT>

Arguments:
  <INPUT>
          

Options:
  -o, --output <OUTPUT>
          

  -f, --format <FORMAT>
          Possible values:
          - viewpoints:       Viewpoint diagram model (OAB/SAB/LAB/PAB) as JSON
          - elk:              ELK layout graphs of the viewpoint diagrams as JSON
          - html:             Self-contained HTML viewer of the viewpoint diagrams
          - mermaid
          - plant-uml
          - operational
          - functional
          - sequence
          - state-machine
          - component
          - physical
          - class
          - tree
          - capability
          - functional-chain
          - all[default: mermaid]

      --title <TITLE>
          [default: "System Architecture"]

      --view <VIEW>
          Restrict the output to one kind of view: oab, sab, lab, pab, msm (mode and state machines), es (scenarios), cap, cdb, pbs, req (requirements) or par (parametric)

      --layout <LAYOUT>
          Layout file (folds, open containers, manual placement) to show the diagrams with. Default: `<model>.layout.json` next to the model, when it exists

      --theme <THEME>
          Color theme of the HTML viewer (-f html): a preset (arclang-default, capella-classic, colorblind-safe, print-grayscale, high-contrast, monochrome-document) or an arclang-theme.json file. A file that breaks a color rule is refused

      --open
          

  -v, --verbose
          

  -c, --config <CONFIG>
          

      --as <PATH>
          The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file

  -h, --help
          Print help (see a summary with '-h')

$ arclang explorer --help
Usage: arclang explorer [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
  -o, --output <OUTPUT>  
      --open             Open in browser after generation
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang export --help
Usage: arclang export [OPTIONS] --output <OUTPUT> --format <FORMAT> <INPUT>

Arguments:
  <INPUT>
          

Options:
  -o, --output <OUTPUT>
          

  -f, --format <FORMAT>
          Possible values:
          - capella
          - json
          - yaml
          - xml
          - markdown
          - mermaid
          - plant-uml
          - html
          - pdf
          - terraform
          - sys-ml
          - sysml-json:         The abstract syntax of the SysML v2 export, as the JSON records the API serves under /api/sysml-v2
          - simulink
          - simulink-connector: What the Capella-Simulink connector exports: the pivot (`.mlcore`) and the MATLAB script that builds the Simulink project; the input is an ArcLang model or a `.capella` file
          - fmi
          - req-if
          - c-headers
          - proto
          - geojson:            The located elements and physical links on a map (RFC 7946 GeoJSON)
          - step:               The product structure and the shapes for CAD (STEP AP242, ISO 10303-242)
          - modelica:           A Modelica package of the physical architecture (OpenModelica): `output` is a DIRECTORY
          - c:                  Portable C99 of the state machines (`<model>.h/.c`, init/step), the I/O interface `arclang_io.h`, the glue of each `io_binding` and the host implementation of the I/O for SIL: `output` is a DIRECTORY
          - fmu:                The generated C as an FMI 2.0 co-simulation FMU (`<model>.fmu`, with this computer's binary when $CC or cc compiles it) and the inputs and model-level reference of each executed case: `output` is a DIRECTORY
          - zephyr:             A Zephyr application of the model for a target package (`--target`, else the io_binding's): the C, the glue, the target's arclang_io, drivers, devicetree overlay, build files and emulator: `output` is a DIRECTORY
          - vhdl:               VHDL-2008 of the state machines allocated to programmable logic (one entity each and its Wishbone wrapper), the register map (JSON, LiteX csr.csv), the C driver and the bit-exact fixed-point C reference: `output` is a DIRECTORY

      --no-placement
          Modelica only: write the structure without the Placement, Line, Icon and Diagram annotations that make Modex and OMEdit draw it

      --split
          Modelica only: one file per class in a `<Package>/` folder (the structured layout of a Modelica library) instead of one file; Modex browses a package by its folders

      --strategy <STRATEGY>
          Simulink connector only: what to export, as the Capella-Simulink connector's operations: functions, functional-chains, state-machines or data-pkg
          
          [default: functions]

      --element <ELEMENTS>
          Simulink connector only: the elements to export, by Capella id or by name (repeat it, or separate them by commas); by default the strategy's roots (the top functions, every chain, every state machine, the layers' data packages)

      --leaf-functions <LEAF_FUNCTIONS>
          Simulink connector only: leaf functions as `model` (one Simulink model each, referenced) or as `subsystem`
          
          [default: model]

      --port-naming <PORT_NAMING>
          Simulink connector only: ports named after the functional exchange (`ExchangeItem`) or after the Capella port (`CapellaElement`)
          
          [default: ExchangeItem]

      --target <TARGET>
          Zephyr only: the target package (default: the io_binding's `target:`)

      --binding <BINDING>
          Zephyr only: the io_binding the controller runs (default: the only one)

  -v, --verbose
          

  -c, --config <CONFIG>
          

      --as <PATH>
          The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file

  -h, --help
          Print help (see a summary with '-h')

$ arclang import --help
Usage: arclang import [OPTIONS] --format <FORMAT> --output <OUTPUT> <INPUT>

Arguments:
  <INPUT>
          

Options:
  -f, --format <FORMAT>
          Possible values:
          - capella
          - sysml:     SysML v2: a .sysml or .kerml text, a directory of them (one model), or a JSON listing of Systems Modeling API records
          - mermaid
          - plant-uml
          - json
          - yaml
          - xml
          - doors
          - req-if

  -o, --output <OUTPUT>
          

  -v, --verbose
          

  -c, --config <CONFIG>
          

      --as <PATH>
          The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file

  -h, --help
          Print help (see a summary with '-h')

$ arclang diff --help
Semantic diff between two model versions: compares by stable identity (UUID), so moving blocks is no change and renaming an element is a modification, not a remove+add

Usage: arclang diff [OPTIONS] <OLD> [NEW]

Arguments:
  <OLD>  The old version of the model (or, with --from, the model file)
  [NEW]  The new version of the model (omit with --from)

Options:
      --json                           Output as JSON (for CI pipelines)
      --from <FROM>                    Compare the file as committed at this git revision...
      --to <TO>                        ...with the file at this revision (default: the working tree, WORKTREE)
  -f, --format <FORMAT>                text, json, md or html: the rich report with layers, consequences and layout [possible values: text, json, md, html]
  -o, --output <OUTPUT>                Write the report to this file
      --gate-standard <GATE_STANDARD>  The standard of the gate in the consequences: ISO26262, DO178C or IEC61508 [default: ISO26262]
  -v, --verbose                        
  -c, --config <CONFIG>                
      --as <PATH>                      The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help                           Print help

$ arclang history --help
The commits that changed one element, found by the semantic diff between successive revisions of the model

Usage: arclang history [OPTIONS] <INPUT> <ELEMENT>

Arguments:
  <INPUT>    
  <ELEMENT>  The element: its id or unique name

Options:
      --limit <LIMIT>    The most commits listed [default: 20]
      --json             
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang merge --help
Semantic three-way merge by element identity: a git merge driver for .arc and .layout.json files (`arclang merge --install`)

Usage: arclang merge [OPTIONS] [BASE] [OURS] [THEIRS]

Arguments:
  [BASE]    The common ancestor (git's %O)
  [OURS]    Our version (git's %A)
  [THEIRS]  Their version (git's %B)

Options:
  -o, --output <OUTPUT>  Write the result here (git's driver passes %A); default: standard output
      --path <PATH>      The path of the file in the repository (git's %P): where imports resolve, and what kind of file it is
      --json             Describe the outcome as JSON on standard output
      --no-compile       Do not compile the result
      --install          Set git up to use this merge for .arc and .layout.json files
  -y, --yes              With --install: do not ask
      --dry-run          With --install: show what would change and stop
      --binary <BINARY>  With --install: the arclang to run (default: this one)
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang baseline --help
Baselines an auditor accepts: the gate, the coverage and the exports, bound to a git tag by a manifest

Usage: arclang baseline [OPTIONS] <COMMAND>

Commands:
  create  Check the tree is clean and the model compiles, run the gate, write baselines/<name>/ and tag the commit baseline/<name>
  list    The baselines of the repository
  diff    The semantic diff between two baselines, with their gate reports
  verify  Check that the files still match the manifest and the tag
  help    Print this message or the help of the given subcommand(s)

Options:
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang baseline create --help
Check the tree is clean and the model compiles, run the gate, write baselines/<name>/ and tag the commit baseline/<name>

Usage: arclang baseline create [OPTIONS] <NAME>

Arguments:
  <NAME>  

Options:
      --standard <STANDARD>  iso26262, do178c or iec61508 [default: iso26262]
      --model <MODEL>        The model file (default: the only .arc file at the top of the repository)
      --require-pass         Refuse to make a baseline of a model whose gate fails
      --allow-dirty          Allow uncommitted changes (the baseline is then not reproducible)
  -v, --verbose              
  -c, --config <CONFIG>      
      --as <PATH>            The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help                 Print help

$ arclang ci --help
CI/CD: write the pipelines (`ci init`), run what a pipeline runs (`ci run`)

Usage: arclang ci [OPTIONS] <COMMAND>

Commands:
  init    Write the pipeline files for GitHub Actions, GitLab CI, Azure DevOps or Jenkins
  run     What a pipeline runs: compile every model, run the production gate, simulate the cases that simulate, write the SARIF file and a summary; non-zero unless every model passes
  models  The models of the repository: the .arc files no other .arc imports
  help    Print this message or the help of the given subcommand(s)

Options:
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang ci init --help
Write the pipeline files for GitHub Actions, GitLab CI, Azure DevOps or Jenkins

Usage: arclang ci init [OPTIONS]

Options:
      --provider <PROVIDER>
          The CI system (default: the one the git remote `origin` points at) [possible values: github, gitlab, azure, jenkins, all]
      --standard <STANDARD>
          The standard of the production gate [default: iso26262] [possible values: iso26262, do178c, iec61508]
      --model <MODELS>
          A model the pipeline checks, relative to the repository root (repeatable; default: every entry point)
      --force
          Overwrite files that exist
      --dry-run
          Print the files, write nothing
      --arclang-version <ARCLANG_VERSION>
          The ArcLang release the pipeline installs (default: this compiler's)
      --release-repo <RELEASE_REPO>
          owner/repo of the GitHub releases to download the binary from [default: Mbaroudi/arclang]
      --branch <BRANCH>
          The branch whose pushes run the pipeline (default: the repository's default branch)
  -v, --verbose
          
  -c, --config <CONFIG>
          
      --as <PATH>
          The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help
          Print help

$ arclang ci run --help
What a pipeline runs: compile every model, run the production gate, simulate the cases that simulate, write the SARIF file and a summary; non-zero unless every model passes

Usage: arclang ci run [OPTIONS] [MODELS]...

Arguments:
  [MODELS]...
          Models to examine (default: every entry-point model of the repository)

Options:
      --standard <STANDARD>
          [default: iso26262]
          [possible values: iso26262, do178c, iec61508]

      --sarif <SARIF>
          Write the SARIF 2.1.0 file here

      --summary <SUMMARY>
          Write a Markdown summary here (for the job summary)

      --verify <VERIFY>
          Possible values:
          - auto:  Simulate the cases of the models that have some
          - never[default: auto]

      --allow-empty
          Succeed when there is no model at all (otherwise that is a failure: nothing was checked)

  -v, --verbose
          

  -c, --config <CONFIG>
          

      --as <PATH>
          The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file

  -h, --help
          Print help (see a summary with '-h')

$ arclang report --help
The pull-request report: semantic diff, impact, gate before and after

Usage: arclang report [OPTIONS] --from <FROM> [MODELS]...

Arguments:
  [MODELS]...  Models to compare (default: every entry-point model of the repository)

Options:
      --pr                   The pull-request report: the semantic diff, the impact, the gate before and after
      --from <FROM>          The base: a branch, tag or commit (the target branch of the pull request)
      --to <TO>              The head (default: the working tree)
  -f, --format <FORMAT>      [default: md] [possible values: md, json, html]
  -o, --output <OUTPUT>      Write the report here (default: standard output)
      --out-dir <OUT_DIR>    Write the before and after pictures (SVG) under this directory, as <dir>/diagrams/
      --standard <STANDARD>  [default: iso26262] [possible values: iso26262, do178c, iec61508]
      --fail-on <FAIL_ON>    blocker: exit 1 on a new blocker or a model that no longer compiles; major: also on a regression (requirement, constraint, budget, simulation); never: always 0 [default: blocker]
      --note <NOTE>          A line of Markdown added to the report (where to find the pictures, for instance)
      --allow-empty          Succeed when there is no model at all
  -v, --verbose              
  -c, --config <CONFIG>      
      --as <PATH>            The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help                 Print help

$ arclang sarif --help
Compiler diagnostics and gate blockers as a SARIF 2.1.0 log

Usage: arclang sarif [OPTIONS] [MODELS]...

Arguments:
  [MODELS]...  Models to examine (default: every entry-point model of the repository)

Options:
      --standard <STANDARD>  [default: iso26262] [possible values: iso26262, do178c, iec61508]
  -o, --output <OUTPUT>      Write the SARIF file here (default: standard output)
      --fail-on <FAIL_ON>    error: exit 1 when a model does not compile or its gate fails; never: always 0 [default: error]
  -v, --verbose              
  -c, --config <CONFIG>      
      --as <PATH>            The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help                 Print help

$ arclang verify --help
Verification by simulation: run the test cases that `simulate:` in OpenModelica (ARCLANG_OMC, or Docker with ARCLANG_OMC_DOCKER), check their `expects:` and cache the verdicts for `check`, `gate` and tables

Usage: arclang verify [OPTIONS] [INPUT]

Arguments:
  [INPUT]  

Options:
      --check-tools          Do not simulate: report what is installed to run OpenModelica (Docker, the image, the Modelica library, a local omc); with --json, as a machine-readable diagnosis
      --test <TEST>          Only this test case (id or name)
      --json                 Print each outcome as JSON
      --replay <CASE>        Do not simulate: print, as JSON, the results kept of the last run of this test case (id or name), for the workbench to replay on the diagram: the time, each part's values, each expectation and the first instant it fails
      --point <POINT>        With --replay: the point of the sweep (0 is the first) [default: 0]
      --list                 Do not simulate: list, as JSON, the test cases that simulate and whether results of their last run are kept for --replay
      --statistics <ENGINE>  Do not simulate: analyze the samples of the last run of a Monte Carlo case (--test) with R or Python (`r` or `python`): failure probability by a normal fit, influence of each parameter (PRCC, SRRC; delta and S1 with SALib). The verdict stays the compiler's
      --drawings             Do not simulate: list, as JSON, the Modelica classes of the model worth drawing (each simulated case's model, each configuration's system)
      --drawing <CLASS>      Do not simulate: print OpenModelica's instance of this Modelica class (getModelInstance: its components, icons, placements and connections) as JSON, for VS Code to draw it
  -v, --verbose              
  -c, --config <CONFIG>      
      --as <PATH>            The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help                 Print help

$ arclang sil --help
Software in the loop: compile the C generated from the state machines (`export -f c`) on this computer, run each test case that `execute:`s with its input vectors, compare the outputs with the model-level run step by step and judge its `expects:` on both

Usage: arclang sil [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --test <TEST>      Only this test case (id or name)
      --cc <COMPILERS>   The C compiler (gcc, clang, gcc-15...); repeat it to run every case with each. Default: $CC, else cc
      --keep <KEEP>      Keep the generated files, harnesses and binaries in this directory
      --json             Print the outcomes as JSON
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang cosim --help
Co-simulation in OMSimulator: each test case that `execute:`s, as a standard FMI co-simulation. The behavior's FMU (`export -f fmu`), the plant's (built by OpenModelica, or the FMU the case gives) and the case's inputs are connected in an SSP package that OMSimulator runs; the run is judged as SIL judges the C: the `expects:` on it, step by step against the model's own loop. Without OMSimulator here, the command runs in ArcLang Studio (Docker). See docs/cosimulation.md

Usage: arclang cosim [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --test <TEST>      Only this test case (id or name)
      --cc <COMPILER>    The C compiler the behavior's FMU is built with. Default: $CC, else cc
      --keep <KEEP>      Keep each case's SSP (cosim.ssp, the FMUs inside), result and logs in this directory
      --json             Print the outcomes as JSON
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang pil --help
Processor in the loop: build the generated C for a target package (Zephyr, `zephyr/litex_vexriscv`), run it on the target's processor in its emulator (Renode), drive each test case that `execute:`s through the bound channels (or the step() API), compare the outputs with the model-level run step by step and judge its `expects:` on both

Usage: arclang pil [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --test <TEST>      Only this test case (id or name)
      --target <TARGET>  The target package (default: the io_binding's `target:`)
      --keep <KEEP>      Keep the applications, builds, plans and logs in this directory
      --json             Print the outcomes as JSON
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang hdl --help
Hardware in simulation: the VHDL of each state machine allocated to programmable logic (`export -f vhdl`) simulated by GHDL through its registers, each test case that `execute:`s compared step by step with the bit-exact fixed-point C (difference 0) and with the model (within the quantisation tolerance), its `expects:` judged; `--synth` also synthesises it for its node's ECP5 (Yosys, nextpnr-ecp5, ecppack)

Usage: arclang hdl [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --test <TEST>           Only this test case (id or name)
      --synth                 Synthesise, place and route each block, report its resources and Fmax
      --as-if <DEVICE[@MHZ]>  With --synth: every machine as if allocated to this ECP5 part, at this clock (DEVICE[@MHZ], e.g. LFE5U-25F-6BG381C@25)
      --machine <MACHINE>     With --synth: only this machine (name or id)
      --keep <KEEP>           Keep the VHDL, the testbenches, the C reference and the netlists in this directory
      --json                  Print the outcomes as JSON
  -v, --verbose               
  -c, --config <CONFIG>       
      --as <PATH>             The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help                  Print help

$ arclang soc --help
The processor and the programmable logic together: one LiteX SoC (a VexRiscv running the Zephyr application, the blocks of the machines allocated to programmable logic on its bus) simulated cycle by cycle in Verilator, each test case that `execute:`s such a machine run through the driver and compared, as `hdl` compares the VHDL, with the fixed-point C and the model; `--board` also builds the same SoC into one bitstream; `--port` runs the cases on the board instead

Usage: arclang soc [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --test <TEST>      Only this test case (id or name)
      --bitstream        Build the bitstream, for the node's board (board:, else the board of its part)
      --board <BOARD>    Build the bitstream for this board (ulx3s, colorlight_i5, colorlight_i9, ecp5_evn)
      --no-sim           Do not simulate (with --board: the bitstream only)
      --gate-level       Simulate the SoC as synthesised for the ECP5 by Yosys (a netlist of ECP5 cells), not as written
      --port <PORT>      Run the cases on the board through this serial port, the board holding the bitstream (implies --no-sim)
      --keep <KEEP>      Keep the application, the SoC, the simulator and the bitstream in this directory
      --json             Print the outcomes as JSON
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang partition --help
HW/SW partitioning: every machine measured as C on the processor (arclang pil: the step's time, the code's footprint) and as VHDL on the logic (arclang hdl --synth --as-if: resources, Fmax), what fits its period, what the model allocates today; kept beside the model for the table kind `partition`

Usage: arclang partition [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --target <TARGET>    The target package of the C (else the bindings', else zephyr/litex_vexriscv)
      --device <DEVICE>    The ECP5 part of the logic (else the first logic node's, else LFE5U-25F-6BG381C)
      --clock <CLOCK>      The clock of the logic, MHz (else the node's, else 25)
      --machine <MACHINE>  Only this machine (name or id)
      --dry-run            Print the two runs, run nothing
      --json               The measurements as JSON
  -v, --verbose            
  -c, --config <CONFIG>    
      --as <PATH>          The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help               Print help

$ arclang schedule --help
Tasks and scheduling: the io_bindings of a target as tasks (a period and a priority each), the worst response time of each from the step times arclang partition measured, whether every task meets its period (fixed-priority response-time analysis)

Usage: arclang schedule [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --target <TARGET>    The target package (else the bindings')
      --wcet <MACHINE=US>  A step time given instead of measured: MACHINE=MICROSECONDS (repeatable)
      --prove              Run every task together on the target first (its emulator): each period proved kept, the step times under load
      --cycles <CYCLES>    With --prove: cycles of the longest period to run [default: 10]
      --keep <KEEP>        With --prove: keep the application, the build, the plan and the logs in this directory
      --json               The analysis as JSON
  -v, --verbose            
  -c, --config <CONFIG>    
      --as <PATH>          The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help               Print help

$ arclang realize --help
Climb the realization ladder (docs/realization.md): for each requirement, run in order what each stage is missing or stale (verify, sil, pil, hdl, soc, twin), read the ladder back after each step, stop a requirement's climb at a failure. --dry-run prints the plan and the gaps (a requirement nothing climbs) without running

Usage: arclang realize [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --requirement <REQUIREMENT>  Only this requirement (id or name)
      --up-to <STAGE>              Climb up to this stage only: simulation, sil, pil, hdl, soc, board or twin
      --dry-run                    Print the plan and the gaps, run nothing
      --keep-going                 Go on past a failure or an error (every step that can run runs)
      --board                      Include the board (the bitstream through --port): off by default, it needs the hardware
      --json                       The plan, the runs and the ladder after, as JSON (the steps' output captured)
  -v, --verbose                    
  -c, --config <CONFIG>            
      --as <PATH>                  The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help                       Print help

$ arclang twin --help
Run the digital twins of a model: each `twin`'s physical model driven by its measured data (drives:) in OpenModelica, compared to the measurements (compares:) and checked against its expects:

Usage: arclang twin [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --twin <TWIN>      Only this twin (id or name)
      --json             Print the outcomes as JSON (with the curves, for VS Code)
      --list             Do not run: list the twins as JSON
      --live             Follow the twin's live data (mqtt, opcua, kafka, http): run it over the latest window at every refresh, until stopped (or --for); with --json, one JSON line per run
      --for <SECONDS>    With --live: stop after this many seconds
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang table --help
Live tables and matrices of a model (requirement coverage, traceability, allocation, N², ICD, elements), computed by the compiler: JSON with ids and UUIDs, CSV, TSV, Markdown, HTML or Excel

Usage: arclang table [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --name <NAME>                    A table the model declares, by name or id (default: every declared table)
      --kind <KIND>                    Compute a table the model does not declare: requirements_coverage, traceability_matrix, allocation_matrix, interface_n2, icd, elements, realization, partition or schedule
      --scope <SCOPE>                  What the rows are taken from: a layer (OA, SA, LA, PA, EPBS) or an element
      --row-type <ROW_TYPE>            The kind of the rows (`elements`), e.g. Requirement or LogicalComponent
      --columns <COLUMNS>              The columns shown (comma separated); for a matrix, the kinds of its columns
      --rows <ROWS>                    For a matrix: the kinds (or layers) of its rows (comma separated)
      --kinds <KINDS>                  For a traceability matrix: the trace kinds (comma separated)
      --filter <FILTER>                Keep the rows matching: words, column:text, column=text, column!=text, is:gap, -term
      --gaps                           Keep only the rows with a gap or a failure
  -f, --format <FORMAT>                [default: json] [possible values: json, csv, tsv, md, html, xlsx]
  -o, --output <OUTPUT>                Write to this file instead of stdout (needed for xlsx)
      --gate-standard <GATE_STANDARD>  The standard the gate column is computed against: ISO26262, DO178C or IEC61508 [default: ISO26262]
      --list                           List the tables the model declares and the kinds the compiler computes
      --declaration                    Print the `table` declaration of the table asked for, as ArcLang source
  -v, --verbose                        
  -c, --config <CONFIG>                
      --as <PATH>                      The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help                           Print help

$ arclang impact --help
Change-impact analysis: what a change to elements, a proposed edit (what-if) or the changes since a git revision reach, and why

Usage: arclang impact [OPTIONS] <INPUT> [ELEMENT]

Arguments:
  <INPUT>    
  [ELEMENT]  Element id or unambiguous name (e.g. "REQ-AEB-004"); same as --element

Options:
  -e, --element <ELEMENTS>             A changed element (repeatable): its id, unique name or Owner.port
      --change <CHANGE>                A proposed change, never written: one `arclang edit` request or a JSON array of them, inline, `@file.json`, or `-` for stdin
      --delete <DELETE>                What if this element were deleted, with the traces and list entries naming it
      --since <SINCE>                  The changes since a git revision (HEAD, main, a commit)
      --current <CURRENT>              With --since: the current text of the model, when it is not the file on disk (an editor's unsaved buffer)
      --depth <DEPTH>                  How far the change is followed (links from a seed) [default: 4]
      --kinds <KINDS>                  The kinds of link followed, comma separated (default: all): realization, allocation, deployment, exchange, interface, chain, satisfies, verifies, safety, containment, typing, constraint, view, behavior, reference
      --direction <DIRECTION>          both, downstream (what depends on the seed) or upstream (what it depends on) [default: both]
      --gate-standard <GATE_STANDARD>  The standard of the production gate: ISO26262, DO178C or IEC61508 [default: ISO26262]
  -f, --format <FORMAT>                [default: text] [possible values: text, json, md, html, tsv, xlsx]
  -o, --output <OUTPUT>                Write to this file instead of stdout (required for xlsx)
  -v, --verbose                        
  -c, --config <CONFIG>                
      --as <PATH>                      The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help                           Print help

$ arclang trace --help
Usage: arclang trace [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --from <FROM>      With --review: only the traces from this element (id or name)
      --to <TO>          With --review: only the traces to this element (id or name)
      --validate         
      --suspects         List the suspect traces: reviewed, and one of their ends changed since
      --review           Mark traces as reviewed (all, or those --from / --to): write the fingerprints of their two ends in the file, as `reviewed: "..."`
      --print            With --review: print the reviewed source instead of writing the file
      --matrix           
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang info --help
Usage: arclang info [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --metrics          
      --dependencies     
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang fmt --help
Format .arc sources: whitespace only, comments and order are kept

Usage: arclang format [OPTIONS] <INPUT>

Arguments:
  <INPUT>  A .arc file, or a directory formatted recursively

Options:
      --check            Change nothing; exit 1 if any file is not formatted
      --write            Rewrite the files in place instead of printing to stdout
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang set --help
Set one attribute of one element in a model file (comments and layout are kept; refused unless the edited model compiles)

Usage: arclang set [OPTIONS] <INPUT> <ELEMENT> <KEY> <VALUE>

Arguments:
  <INPUT>    The .arc file that declares the element
  <ELEMENT>  Identifier of the element, or its name when it writes no id
  <KEY>      Attribute name
  <VALUE>    Value, as ArcLang source: '"text"', '25 ms', '[A, B]'

Options:
      --write            Rewrite the file in place instead of printing to stdout
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang unset --help
Remove one attribute of one element in a model file

Usage: arclang unset [OPTIONS] <INPUT> <ELEMENT> <KEY>

Arguments:
  <INPUT>    
  <ELEMENT>  Identifier of the element, or its name when it writes no id
  <KEY>      Attribute name

Options:
      --write            Rewrite the file in place instead of printing to stdout
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang rename --help
Rename one element in a model file. Refused when the element is known by its name elsewhere: its identity must not change

Usage: arclang rename [OPTIONS] <INPUT> <ELEMENT> <NAME>

Arguments:
  <INPUT>    
  <ELEMENT>  Identifier of the element
  <NAME>     The new name

Options:
      --write            Rewrite the file in place instead of printing to stdout
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang workbench --help
Everything a modeling workbench shows of one model, as JSON: the diagrams as the viewer mounts them, the explorer document, every element with its typed attributes, the findings (named after their rule) and the production gate. A model that does not compile gives `{"success": false, "errors": [...]}`

Usage: arclang workbench [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --gate-standard <GATE_STANDARD>  The standard the gate is run against: ISO26262, DO178C or IEC61508 [default: ISO26262]
      --exports                        Also render the interop exports (SysML v2, ReqIF, C headers, Protobuf)
      --rev <REV>                      The model as committed at this git revision, with its layout file
  -v, --verbose                        
  -c, --config <CONFIG>                
      --as <PATH>                      The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help                           Print help

$ arclang edit --help
Apply one edit, written as JSON, to a model file: {"op": "set" | "unset" | "rename" | "add" | "add_raw" | "remove" | "move" | "add_trace" | "remove_trace" | "wrap_fragment" | "wrap_invariant" | "reconnect" | "duplicate" | "duplicate_many", ...}. Comments and layout are kept; refused unless the edited model compiles and shows what was asked. Prints {"success": true, "source": ...} or {"success": false, "error": ...}; --write writes the file back

Reconnect: {"op": "reconnect", "kind": K, "from": A, "to": B, "name": N?, "new_from": C?, "new_to": D?} moves the source and/or the target of the relationship of kind K from A to B (named N when several join them); both, swapped, reverse it. K is a kind of the element graph: ComponentExchange, FunctionalExchange, OperationalExchange, PhysicalLink, PhysicalExchange, Transition, Message, Trace or Association (`arclang workbench` lists every relationship with its kind). Refused when a port goes the wrong way (a source leaves by an out or inout port, a target arrives by an in or inout port), when an exchange would join an element to itself, or when the compiler warns about the result (a trace whose ends break the trace rules of `arclang metamodel`).

Duplicate: {"op": "duplicate", "element": E, "container": C?, "layer": L?} copies the declaration of E with what it holds, beside it or into C or the layer L; every id of the copy is made unique (LC-X becomes LC-X-2), an element without id gets a new name. {"op": "duplicate_many", "elements": [E, ...], "container": C?} copies several at once, with the exchanges, links and traces declared between two of them, joined to the copies.

A move of a port ({"op": "move", "element": "LC-A.p", "container": "LC-B"}) takes the ends of its exchanges with it. A rename of a name no element has renames the relationship of that name.

Usage: arclang edit [OPTIONS] --request <REQUEST> <INPUT>

Arguments:
  <INPUT>
          

Options:
      --request <REQUEST>
          The edit request as JSON, or `-` to read it from stdin

      --write
          Rewrite the file in place (the JSON answer is still printed)

  -v, --verbose
          

  -c, --config <CONFIG>
          

      --as <PATH>
          The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file

  -h, --help
          Print help (see a summary with '-h')

$ arclang transition --help
Arcadia transition: declare on the next level what realizes the elements of this one (oa-to-sa, sa-to-la, la-to-pa). Prints the edited model; --write writes it back

Usage: arclang transition [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --step <STEP>      oa-to-sa, sa-to-la or la-to-pa; omitted with --plan: every step
      --into <INTO>      The logical component (sa-to-la) or physical node (la-to-pa) that receives the created elements
      --plan             Only say what the step would create, as JSON
      --write            
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang rules --help
Print the catalog of validation rules (what `check` reports) as Markdown or JSON

Usage: arclang rules [OPTIONS]

Options:
      --format <FORMAT>
          Possible values:
          - markdown
          - json
          - sysml-library-probe: A SysML v2 package using every standard-library element the SysML export can write (input of tools/sysml_library_index.py)[default: markdown]

  -v, --verbose
          

  -c, --config <CONFIG>
          

      --as <PATH>
          The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file

  -h, --help
          Print help (see a summary with '-h')

$ arclang review --help
Ask a judgment model (TypeSafe's Jev) whether the traces of a model are plausible. Advice only: probabilities, never a verdict. Sends the names and descriptions of the traced elements to api.typesafe.ai and needs TYPESAFE_API_KEY (environment or ./.env)

Usage: arclang review [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
      --threshold <THRESHOLD>
          Report declared traces under this plausibility [default: 0.3]
      --suggest
          Also judge undeclared component/function-to-requirement pairs and report those that may be a missing trace
      --suggest-threshold <SUGGEST_THRESHOLD>
          Report undeclared pairs over this plausibility (with --suggest) [default: 0.8]
      --max-questions <MAX_QUESTIONS>
          Most questions asked; declared traces come first [default: 200]
      --json
          Print the result as JSON
      --dry-run
          Say what would be sent, and send nothing
  -v, --verbose
          
  -c, --config <CONFIG>
          
      --as <PATH>
          The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help
          Print help

$ arclang serve --help
Start the HTTP API. Models given here are served through the Systems Modeling API under /api/systems-modeling/projects

Usage: arclang serve [OPTIONS] [MODELS]...

Arguments:
  [MODELS]...  Model files to serve (one project per model)

Options:
      --port <PORT>                    [default: 5001]
      --history                        Serve each model with its git history: one API commit per git commit that touched the file, the working tree as head
      --history-depth <HISTORY_DEPTH>  Number of git commits served per model with --history [default: 50]
      --token-file <TOKEN_FILE>        Require a bearer token on every API request. The token is the content of this file; without the option it is read from the ARCLANG_API_TOKEN environment variable when that is set
      --users-file <USERS_FILE>        Declare the API users: a file with one `name role token` per line, role being `read` or `write` and token given in clear or as `sha256:<hex digest>`. Every request must then present the token of one of them
      --allow-write                    Accept writes: POST .../commits changes the model file and makes one git commit per request. Needs a token, or a user who may write
  -v, --verbose                        
  -c, --config <CONFIG>                
      --as <PATH>                      The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help                           Print help

$ arclang lsp --help
Usage: arclang lsp [OPTIONS]

Options:
      --stdio            
      --port <PORT>      
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang metamodel --help
Print the language metamodel (element kinds, typed attributes, enumerations, units, trace rules) as Markdown or JSON

Usage: arclang metamodel [OPTIONS]

Options:
      --format <FORMAT>
          Possible values:
          - markdown
          - json
          - sysml-library-probe: A SysML v2 package using every standard-library element the SysML export can write (input of tools/sysml_library_index.py)[default: markdown]

  -v, --verbose
          

  -c, --config <CONFIG>
          

      --as <PATH>
          The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file

  -h, --help
          Print help (see a summary with '-h')

$ arclang safety --help
Usage: arclang safety [OPTIONS] --standard <STANDARD> <INPUT>

Arguments:
  <INPUT>  

Options:
      --standard <STANDARD>  [possible values: iso26262, do178c, iec61508]
      --fmea                 
      --fta                  The fault tree of every hazard: its failure modes, rate and budget
      --report               A safety report in Markdown (hazards, FMEA by risk, fault trees, mitigations)
  -o, --output <OUTPUT>      Where the report is written (default: the terminal)
  -v, --verbose              
  -c, --config <CONFIG>      
      --as <PATH>            The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help                 Print help

$ arclang build --help
Usage: arclang build [OPTIONS] <INPUT>

Arguments:
  <INPUT>  

Options:
  -o, --output <OUTPUT>  
      --incremental      
      --release          
      --target <TARGET>  
  -v, --verbose          
  -c, --config <CONFIG>  
      --as <PATH>        The file the input stands for, when the input is a copy of it (an editor's buffer written to a temporary file): its imports, its cached verdicts and the files next to it are those of this file
  -h, --help             Print help

$ arclang repl
Error: Not implemented: the REPL is not implemented yet