Auriga is a suite of dotnet libraries and tools that are used to deserialize (read), manipulate, and serialize (write) Eclipse Capella™ models. Capella is an open-source Model-Based Systems Engineering (MBSE) tool implementing the Arcadia method; its models are stored as Ecore-based XMI. Auriga makes the Capella semantic model (the five Arcadia architecture layers and the common packages) available as an in-memory .NET object graph, typically to support opinionated template-based code-generation and model transformation, and is a part of modeltopia.
Auriga builds on ECoreNetto for reading the Capella Ecore metamodel, and is a sibling of uml4net and SysML2.NET. Auriga provides a number of libraries that are described in the following sections.
The core library that contains the shared base types (the Auriga.Core namespace) and two generated object models: the Capella semantic metamodel (the Arcadia layers — Operational Analysis, System Analysis, Logical Architecture, Physical Architecture, EPBS — and the common packages) under the Auriga.Model.* namespaces, and the Sirius/GMF diagramming metamodel (the .aird representation model) under the Auriga.Diagram.* namespaces. Together with Auriga.Xmi it provides the capability to read and write Capella models and make them available as an in-memory object graph.
The Auriga.Xmi library provides XMI reader implementations to read Capella semantic model files (.capella / .melodymodeller, the Auriga.Xmi.Model.* namespaces) and Sirius diagram files (.aird, the Auriga.Xmi.Diagram.* namespaces), and an XMI writer implementation to write them back, all built on a metamodel-agnostic XMI runtime (the Auriga.Xmi.Core.* namespaces). It resolves intra-file (xmi:id) and cross-file (href) references, including references that cross .capellafragment boundaries, into a fully resolved object graph. The writer serializes the graph back to Capella-faithful XMI, preserving the fragment layout — see XMI Writer.
The Auriga.Extensions library provides LINQ-style query extension methods over the Auriga object graph, following the uml4net.Extensions pattern: containment navigation (QueryAncestors, QueryRoot, QueryAllFunctions, QueryAllComponents), component-functional allocation (QueryAllocatedFunctions, IsAllocatedTo, QueryAllocatingBlocks), function/component ports and functional exchanges, and cross-layer realization (QueryRealizedFunctions/QueryRealizingFunctions and the component equivalents). See Query Extension Methods.
The Auriga.Rendering library provides the renderer-agnostic intermediate diagram model: DiagramBuilder.Build turns a parsed Sirius representation into a Diagram of Boxes and Edges whose coordinates are absolute and taken from the persisted GMF layout (never computed), pairing every notation view with the Sirius element that names and styles it and with its resolved Capella semantic element. Every item carries a ResolvedStyle (colors, fonts, line patterns, arrows) resolved from the persisted Sirius/GMF styles with Capella-default fallbacks, and SvgExporter serializes a diagram to plain SVG (string, stream or file) with no external dependency.
The Auriga.Reporting tool renders a browsable HTML report of the Capella metamodel from the vendored .ecore files, using the ECoreNetto HtmlReportGenerator — the same report generator used by the sibling projects (uml4net, SysML2.NET). The docker-build-docs-local.sh and docker-build-docs-attested.sh scripts render the report and serve it from an nginx image (HtmlDocs/Dockerfile). See Capella Metamodel HTML Report for build and run instructions. It is a development-time tool and is not published as a package.
Install the packages from NuGet (once published):
dotnet add package Auriga
dotnet add package Auriga.Xmi
dotnet add package Auriga.Extensions
Load a Capella project, navigate the Arcadia layers, query it, and write it back:
using Auriga.Xmi;
using Auriga.Extensions;
// 1) Load a project — pass the .capella / .melodymodeller file or the project directory.
// Referenced .capellafragment files are discovered and resolved into one object graph.
var project = CapellaProject.Load("In-Flight Entertainment System/In-Flight Entertainment System.capella");
// 2) Navigate the Arcadia layers as first-class properties (null when a layer is absent).
var logical = project.LogicalArchitecture;
var physical = project.PhysicalArchitecture;
// 3) Query with LINQ and the Auriga.Extensions methods.
foreach (var component in logical!.QueryAllComponents())
{
foreach (var function in component.QueryAllocatedFunctions())
{
// function.IsAllocatedTo(component) == true
}
}
// Any element can walk its own subtree; combine with LINQ for ad-hoc queries.
var exchanges = project.Project!
.QueryAllContainedElements()
.OfType<Auriga.Model.Fa.IFunctionalExchange>();
// 4) Write the (possibly modified) model back to disk — the fragment layout is preserved.
var writer = XmiWriterBuilder.Create().Build();
writer.Write(project.Project!, "out/In-Flight Entertainment System.capella");See ContainerList Design, Query Extension Methods and XMI Writer for the containment, query and write-back APIs in depth.
Auriga is in early development and has not yet had its first release. Once published, the packages will be available on NuGet:
Auriga— the Capella object model (Auriga.Model.*) and the Sirius/GMF diagram object model (Auriga.Diagram.*)Auriga.Xmi— the.capella/.melodymodeller/.airdreaders and writersAuriga.Extensions— query extension methodsAuriga.Rendering— the intermediate diagram model built from the persisted.airdlayout
GitHub Actions are used to build and test the Auriga libraries.
| Branch | Build Status |
|---|---|
| Master |  |
| Development |  |
Background and design documentation lives in the docs folder:
- Capella Metamodel Inventory — the
.ecorefiles, the inter-package dependency graph, and the v1 code-generation scope - Arcadia Semantics Not Visible in Raw Ecore — the layer, allocation, realization, and containment conventions the public API must respect
- ECoreNetto Validation Against the Capella Metamodel — proof that ECoreNetto loads the full Capella metamodel with fully resolved references
- Capella Metamodel HTML Report — building and hosting the browsable metamodel report (
Auriga.Reporting, with Docker build scripts) - Query Extension Methods — the
Auriga.ExtensionsLINQ query set for functions, components, ports, exchanges, and cross-layer allocation/realization - ContainerList Design — the non-bypassable
Collection<T>-based containment collection and its exclusive-ownership (reject-not-steal) semantics - XMI Writer — serializing the object graph back to Capella-faithful XMI (
Auriga.Xmi), fragment layout, and the fidelity model - Validation Against Real Capella Models — the round-trip validation harness, per-model results, and exactly how out-of-scope content (other versions, add-on viewpoints, diagrams) is handled
Eclipse Capella™ is an open-source MBSE tool hosted by the Eclipse Foundation. It implements the Arcadia method, a structured engineering method for the definition and validation of complex systems architecture. Learn more at https://mbse-capella.org and https://eclipse.dev/capella/.
As part of our commitment to security and transparency, this project includes a Software Bill of Materials (SBOM) in the associated NuGet packages. The SBOM provides a detailed inventory of the components and dependencies included in the package, allowing you to track and verify the software components, their licenses, and versions.
Why SBOM?
- Improved Transparency: Gain insight into the open-source and third-party components included in this package.
- Security Assurance: By providing an SBOM, we enable users to more easily track vulnerabilities associated with the included components.
- Compliance: SBOMs help ensure compliance with licensing requirements and make it easier to audit the project's dependencies.
You can find the SBOM in the NuGet package itself, which is automatically generated and embedded during the build process.
The Auriga libraries are provided to the community under the Apache License 2.0.
Eclipse Capella™ is a trademark of the Eclipse Foundation. Auriga is an independent project and is not affiliated with or endorsed by the Eclipse Foundation.
Contributions to the code-base are welcome. However, before we can accept your contributions we ask any contributor to sign the Contributor License Agreement (CLA) and send this digitally signed to s.gerene@stariongroup.eu. You can find the CLA's in the CLA folder.