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.
Select a System or System Actor and choose Add port in the browser or Properties. Choose Standard or Flow, then Create port. Select the port and choose Connect boundary exchange; the picker identifies compatible ports by owner, name and alias. Create the other participant's matching port first if none exists. Functions expose separate input/output port actions. Use Create relationship for allocations, functional exchanges, capability involvement, mission links, state transitions and interface relationships; Data & interfaces holds reusable payloads and contracts.
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.

Model explorer groups roots by engineering purpose and opens one container's direct children. Breadcrumbs navigate ownership; Allocated work is listed separately. Search names, kinds or @aliases to find elements with ancestor context. Results are paged in groups of 100. Collapse all folds the outline; Locate clears the filter and reveals the selected element's ancestry.

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. Accepted model/source history retains up to 100 edits within an estimated 32 MiB history budget.

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 per-file drafts, syntax highlighting, live linting and explicit Apply all. Projects can use relative includes to organize source into files. For example:

arcadia 3;
project harbor "Harbor assistance" {
    oa_entity control "Harbor control" {}
    oa_activity respond "Respond to requests" {
        oa_activity assess "Assess assistance" {}
    }
    allocation performs "Performs" { source @control; target @assess; }
    sa_system service "Harbor assistance system" {}
    sa_actor operator "Harbor operator" {
        sa_port radio "Radio" {
            contract { Component { kind Standard; orientation Unset; }; };
        }
    }
    sa_function evaluate "Evaluate assistance request" {}
    trace assessment_trace "Operational realization" {
        oa @assess; sa @evaluate; kind Refinement;
    }
}

New declarations may omit IDs; Apply inserts assigned UUIDs into their 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.

Nested elements inherit their enclosing element as semantic parent. Allocation remains an explicit relationship: nesting a function inside a System would confuse containment with responsibility and is rejected. An explicit parent on a nested declaration must agree with its enclosing owner. Flat declarations with parent @alias remain supported. Open the six-file source project for a complete OA/SA example with typed ports, matching functional and boundary exchanges, allocations and saved views.

Applying valid source commits the reachable source bundle as one model transaction. Graphical edits update the owning declarations while preserving unaffected formatting and comments. Invalid source remains in its file buffer with located diagnostics, including while another file is open. Undo text and Undo model are distinct: model Undo/Redo restores the accepted model and its exact source documents together. JSON export carries model semantics; comments and source-file organization belong to the source project. Version 1 source/JSON is migrated explicitly without inventing SA content.

Reparenting a nested element through Properties moves its declaration, descendants and attached comments to the new owner's body, including across files. Existing flat declarations retain their file organization. New children appear inside their owner's source body. Separate general file or group notes from the next declaration with a blank line to keep those notes in place when it moves.

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 all validates a snapshot and saves the source bundle, comparing previously read dependency bytes to reject detected external changes. Each file is replaced atomically; a staged transaction journal allows explicit recovery of interrupted multi-file saves. This is not an atomic multi-file filesystem operation or distributed locking. If recovery is needed, Recover interrupted save appears in Textual model. Dirty New/Open/Close operations offer save/discard/cancel. There is no periodic autosave of unsaved edits. Share or commit the entry file and all included source files together.

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, multi-file source projects, elements, relationships, artifacts and traces. Transactions and transition previews use the same core validation and source writer as the desktop. Writes require the returned ETag in If-Match. One revision protects the accepted model and source bundle together, including comment-only edits. The server retains the current revision only.

Desktop files and hosted resources transfer explicitly; the desktop has no direct server connection. Use Save as to export system.json, import it, then edit using the API. The model interchange endpoint accepts a complete JSON model or standalone canonical source:

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

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.

To preserve authored files and comments, use POST /api/v1/projects/import-source-project with a JSON bundle containing entry and a files map of relative paths to source strings. GET and conditional PUT /api/v1/projects/<resource-id>/source-project exchange that complete accepted bundle. Include resolution uses only the submitted files; the server never opens the client's disk paths. See the REST contract for payloads, located diagnostics and admission limits.

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.