Arcadia Studio is a native Rust/Iced modeling workbench for system engineers. V2 covers Operational Analysis (OA) and System Analysis (SA), with graphical and textual editing of one typed model and a deployable Rust REST service. It is an independent implementation inspired by Arcadia and Eclipse Capella, not a complete Capella or SysML implementation.

The normative language and editing contract defines supported semantics, both representations, validation and migration. Scope states the boundaries. The acceptance, validation and current state records document V2 tests and native Windows/Linux Computer Use verification.

Build and run

Install stable Rust and your platform's native compiler. The workspace declares Rust 1.90; the recorded development builds use Rust 1.98.1. Windows requires Visual Studio Build Tools with Desktop development with C++. Ubuntu/Debian development dependencies are:

sudo apt-get install build-essential pkg-config libxkbcommon-dev libwayland-dev libvulkan-dev libx11-dev libxrandr-dev libxi-dev

From the repository root:

cargo run --locked -p oa-desktop --bin arcadia-studio

Build both desktop and server release executables:

cargo build --release --workspace --locked

Run target/release/arcadia-studio.exe on Windows or ./target/release/arcadia-studio on Linux. No task-specific cache directory is required. A graphical desktop and compatible graphics driver are required; the application uses Iced 0.14 with WGPU and X11/Wayland support. It does not require Java, Eclipse, a browser, an account or a running server.

On the tested Ubuntu 24.04/WSLg environment, Mesa's Vulkan software adapter is required:

sudo apt-get install mesa-vulkan-drivers
WGPU_BACKEND=vulkan VK_DRIVER_FILES=/usr/share/vulkan/icd.d/lvp_icd.x86_64.json ./target/release/arcadia-studio

A compatible native Linux graphics adapter can use the ordinary command. This software-adapter workaround requires the indicated driver file. See the platform verification record for tested environments.

V2 release bundles are dist/ArcadiaStudio-Windows.zip and dist/ArcadiaStudio-Linux.tar.gz, with archive checksums in dist/SHA256SUMS.txt. Extract the bundle and run its arcadia-studio.exe or ./arcadia-studio; Rust is not needed to run a packaged executable. Both bundles include the headless server, examples, specifications and deployment instructions. Linux bundles target the documented Ubuntu 24.04 runtime. Packaged executable and archive evidence is recorded in package verification.

Model operational needs and system responsibilities

The coastal rescue example combines people, an organization, a System of Interest, information and physical exchange items, normal/degraded behavior and code/CAD evidence. Choose New to start an empty project.

The example opens in an architecture view with work nested inside its performers. Each layer also has dedicated functional dataflow and mission/capability views. Regenerate both example formats with matching identities using cargo run --locked -p oa-core --example generate_demo; the command verifies both saved models. Historical migration fixtures remain separate.

In Operational Analysis, create entities, actors, activities and capabilities. Use In selected for semantic decomposition and Allocated for new leaf work performed by a participant. Activities can decompose independently of their performer; roles capture shared operational responsibility.
Switch to System Analysis. Define one System of Interest and external Actors, then functions, missions, capabilities and functional chains. The system boundary has no internal LA/PA components in this version.
Use Create relationship for allocations, interactions/functional exchanges, capability involvement, mission links, state transitions and interface relationships. Add exchange items, typed data, ports and provided/required interfaces in Data & interfaces.
Create focused views. Containment nests semantic children; Architecture · allocated work nests work within performers; Functional dataflow shows work decomposition and exchanges; Missions & capabilities shows objectives and participation. Dashed, italic parent work denotes an allocation summary inferred from its leaves. Ports appear on their owner's boundary. Placement dragging changes geometry. Hide removes a placement; Delete from model removes semantics and dependent references. Use Placement and View properties for exact values.
In Behavior & scenarios, author processes/chains, scenario lifelines and ordered occurrences, including repeated uses of the same exchange and explicit fragments/branches. State machines contain regions and states/modes with guarded transitions, availability and state-action links. Conditions are descriptive, not executable simulation code. Creating records in Behavior or Data preserves your architecture layouts; Show in this diagram adds an explicit placement when desired.
Select an OA or SA element and choose Create / update counterpart. Review dependency scope and counterpart choices, then apply one undoable transaction. Existing counterparts retain their structural choices; reviewed updates compare names/descriptions. Manual traces link other engineering correspondences. Traceability also edits artifact URI, revision and fragment metadata.
Review Model checks, then save .arcadia source or .json. Warnings allow incomplete authoring; structural errors preserve the committed model and rejected draft.

The inspector exposes typed properties, references, ordered lists, aliases and UUID identity. Applying or navigating away attempts to commit the draft; invalid values remain editable. Escaped strings (advanced) uses quoted JSON escapes for exact tabs, line breaks and carriage returns, for example "First\nSecond". UUID changes atomically update dependent references. Model history retains up to 100 edits.

Drag cards to move on a 10-unit grid, drag empty space to pan, and scroll to zoom. Arrange changes the current view layout; Fit frames its projected bounds. SVG exports the current architecture diagram as a view, not an editable model file.

Connections start with orthogonal routes that avoid cards and container headers. Select a connection and drag a line segment to add a bend, or choose Add bend. Drag its circles to adjust the route; Remove bend removes the selected point, and Reset routing restores automatic routing. Drag the connection label independently. Each completed gesture is one undoable edit; Escape cancels a drag. Routes belong to the current diagram and persist in source, JSON, REST and SVG export. Typed ports remain attached to their owning elements. Folding an endpoint container temporarily uses an automatic route; expanding it restores your authored route. Dense diagrams can still need manual adjustment—automatic routing is bounded and does not guarantee an overlap-free result.

Edit the same model as text

Textual model has syntax highlighting, live linting and explicit Apply to model. For example:

arcadia 2;
project harbor "Harbor assistance" {
    oa_entity control "Harbor control" {}
    oa_activity assess "Assess assistance" {}
    allocation performs "Performs" { source @control; target @assess; }
    sa_system service "Harbor assistance system" {}
    sa_function evaluate "Evaluate assistance request" {}
    trace assessment_trace "Operational realization" {
        oa @assess; sa @evaluate; kind Refinement;
    }
}

New declarations may omit IDs; Apply writes assigned UUIDs into canonical source. Keep existing identity clauses to preserve objects. Stable @aliases survive display-name changes and support forward references. The normative specification covers every supported declaration, typed constructor, relationship and persisted diagram field.

Applying valid source commits the whole candidate as one model transaction. Graphical edits regenerate canonical source. Invalid source remains a draft with located diagnostics. Undo text and Undo model are distinct histories. Apply canonicalizes formatting and removes comments; comments and whitespace are not retained model data. Names, aliases, exact strings, typed values, references, occurrence identity and placement data are retained. Version 1 source/JSON is migrated explicitly without inventing SA content.

Save and reopen

Ctrl+S saves, Ctrl+Shift+S saves as, and Ctrl+O opens. An .arcadia suffix selects text; other suffixes select JSON. Opening detects content rather than relying on the filename. Windows uses native dialogs; Linux uses a path-entry dialog with overwrite confirmation and no portal requirement.

Save validates a snapshot and atomically replaces the destination. Normal saves compare the previously read file bytes and reject a detected external change; preserve your draft and use Save as or reopen deliberately. This is a conflict check, not distributed locking. Dirty New/Open/Close operations offer save/discard/cancel. There is no autosave or crash recovery.

REST service and external tools

Run the server without GUI dependencies:

cargo run --locked -p oa-server --bin arcadia-server

The default is 127.0.0.1:8787, with a platform-local data directory. --data-dir PATH, --bind IP:PORT and --token-file PATH configure deployment; binding outside loopback requires a bearer token. See server setup, the REST contract, OpenAPI and deployment examples.

The API queries and edits complete models, canonical source, elements, relationships, artifacts and traces. Transactions and transition previews use the same core validation as the desktop. Writes require the returned ETag in If-Match. The server retains the current revision only.

Desktop files and hosted resources transfer explicitly; the desktop has no direct server connection. Save a model as system.arcadia, import it, then edit using the API:

curl --fail-with-body -X POST http://127.0.0.1:8787/api/v1/projects/import \
  -H 'Content-Type: text/plain' --data-binary @system.arcadia

The response supplies the service resource_id and ETag. After API changes, export /api/v1/projects/<resource-id>/source to a new .arcadia file and open it in the desktop. This preserves model UUIDs, aliases, diagrams, traces and artifact metadata. Importing creates a separate hosted resource. Artifact URIs and revisions are opaque references for code, CAD, schematics, documents and other evidence; the application does not fetch or execute them.

Development

cargo fmt --all -- --check
cargo clippy --workspace --all-targets --locked -- -D warnings
cargo test --workspace --locked
cargo build --release --workspace --locked

crates/oa-core: typed model, semantics, commands/history, references, projections, transition planner, language and persistence.
crates/oa-desktop: Iced state/drafts, typed forms, architecture/behavior views, source highlighting and file workflows.
crates/oa-server: REST transport, conditional writes, bounded queries and atomic local store.

The architecture guide explains extension boundaries. Windows/Linux CI is configured; remote CI was not run in this environment. LA/PA, simulation, native Capella interchange, complete SysML/Capella conformance, direct hosted editing, semantic merge tooling and production-scale collaboration remain outside this prototype.