Hello and welcome back to the Advent of SysML v2 – a daily, hands-on mini-course designed to bring you up to speed with the new SysML v2 standard and the modern Syside tooling that makes you productive from day one.

By the end of this lesson, you will:

• Understand common challenges in managing and reusing SysML v2 models across teams
• Learn about Sysand, the open-source package manager being built for the SysML v2 ecosystem

The challenge of model reuse

As your SysML v2 projects grow beyond a single engineer working in isolation, you’ll encounter a familiar pattern: the same subsystems get modeled over and over again. Sensors, communication modules, power systems – each project recreates them slightly differently. Your team ends up with ten variations of essentially the same component, none quite compatible with the others.

Or perhaps you’re receiving models from suppliers. One vendor sends their subsystem model as version 1.2, another uses 1.5 of your shared interface definitions. Your models don’t align, and you spend hours debugging incompatibilities that shouldn’t exist.

Maybe your organization has established modeling standards: naming conventions, typed properties, interface definitions, but getting everyone to follow them consistently feels like herding cats. Each project drifts a little further from the baseline.

These aren’t new problems. Software engineers faced them decades ago and solved them with package managers – tools that manage, version, and distribute reusable code libraries. Think of npm for JavaScript, pip for Python, Maven for Java, or NuGet for .NET.

The question is: can this approach work for systems modeling?

Introducing Sysand

Sysand is a package manager for SysML v2 and KerML that brings proven software engineering practices to systems modeling. It helps teams manage, share, version, and reuse model libraries with the same discipline that software teams apply to code dependencies.

The SysML v2 and KerML standards actually define two approaches for collaboration:

• First is API-based, defined in the Services & API specification, used by tools like SysON or OpenMBEE Flexo.
• Second is package manager-based, defined in KerML clause 10 using model interchange projects (.kpar files). Until Sysand, this second approach had no implementation.

Sysand fills that gap. It gives SysML v2 models a modular structure through reusable libraries, ensures teams use the correct versions consistently, and provides a unified way to distribute and consume model assets.

Why package management matters

You might be thinking: “This sounds like something for software developers, not systems engineers.”

Fair point. But consider these scenarios:

• Design. Your spacecraft team models the same bus architecture for every mission. Wouldn’t it be better to publish that architecture as a versioned package that every new project imports? When you improve the design, you bump the version, and teams can update deliberately rather than copying the latest file around.
• Compliance. Your automotive OEM maintains strict modeling standards for safety-critical systems. The governance team could publish these standards as an official package. Every new vehicle project imports the same baseline, automatically staying aligned with organizational requirements.
• Integration. You’re integrating subsystem models from three different suppliers. Each supplier delivers their work as a package with explicitly declared dependencies. When they update their interface definitions, the new version propagates cleanly to your integration environment.
• Speed. Your team is prototyping a new system under tight deadlines. NASA’s Ingenuity helicopter used a smartphone processor instead of expensive custom rad-hard components to iterate faster. Similarly, package management lets you use existing, proven model libraries rather than building everything custom. Import tested components, rapidly test configurations, and focus your effort on what’s truly novel.

Package management isn’t about making modeling more like software development. It’s about solving real collaboration problems that emerge when MBSE scales across distributed teams, multiple suppliers, and complex organizational hierarchies.

Takeaway:

• Package management addresses version control, model reuse, and consistency challenges that appear in collaborative MBSE.
• Sysand implements the package manager-based collaboration approach defined in the SysML v2 and KerML standards.

How Sysand works

Let’s say your team wants to distribute a reusable model library called power-systems-lib. This library depends on two other internal packages: comm-protocols-lib for communication interfaces and spacecraft-components-lib for reference spacecraft components.

Here’s the workflow:

1. You initialize a new project and add your SysML source files.
2. Then you declare the dependencies: comm-protocols-lib and spacecraft-components-lib. Sysand will automatically fetch these when someone installs your package.
3. Once your source files are ready, you package everything into a .kpar file for distribution. This packaged file gets published to your internal package index (a storage location for your organization’s model assets).

Now, other engineers can install your package with a single command. Sysand downloads the package, downloads all its dependencies, and makes the source files available locally. Everyone works with the same versions, and dependency resolution happens automatically.

The key insight is that when someone adds power-systems-lib, they don’t just get your model – they get the entire dependency tree resolved correctly. No more “it works on my machine” problems because someone had the wrong version of a shared library.

Takeaway:

• Sysand manages model packages similarly to how software package managers handle code libraries.
• Dependencies are declared explicitly and resolved automatically.
• Distribution happens through package indexes that can be hosted internally or publicly.

Beyond individual projects

Package management becomes even more valuable when you think beyond individual projects. The vision extends to building a collaborative SysML v2 ecosystem where teams can discover, share, and build upon each other’s work.

Consider how open-source software thrives: developers don’t reinvent basic data structures or common algorithms. They import well-tested libraries and focus on solving novel problems. The same pattern could transform systems modeling. Why should every team define SI units when the SysML v2 standard library already provides them? Instead of every team building their own sensor models, communication protocols, or domain ontologies from scratch, proven implementations could be shared as packages.

The Sysand Package Index at sysand.org aims to serve as this central hub. Engineers could search for existing packages before starting from scratch. A small team modeling a satellite could import standard orbital mechanics packages. An automotive startup could leverage industry-standard electrical architecture libraries. Academic researchers could publish reference models that others build upon.

This matters for everyone, not just large organizations. Individual engineers gain access to expertise beyond their immediate team. Small companies can compete by leveraging community resources rather than rebuilding everything. Standards bodies can publish reference implementations as packages, ensuring everyone interprets specifications consistently.

More importantly, shared packages enable true interoperability. Just as USB-C and standardized power sockets allow devices from different manufacturers to work together seamlessly, shared model packages let teams integrate components developed completely separately. When everyone builds against common standard libraries and interface definitions, integration becomes straightforward rather than a custom integration project each time.

The ecosystem also benefits from network effects. As more teams contribute packages, the value grows for everyone. Someone solving a problem today might publish a package that saves dozens of teams from duplicate work tomorrow.

For enterprises, package management still enables strict governance. Version locking supports certification and compliance requirements with precise traceability. When an auditor asks what version of safety requirements you used, you have a definitive answer. Internal package indexes keep proprietary models private while still enabling systematic reuse within the organization.

Takeaway:

• A shared package ecosystem can reduce duplicated effort across the SysML v2 community.
• Public and private packages serve different needs: open collaboration vs. organizational control.
• Network effects make the ecosystem more valuable as more teams contribute and consume packages.

Getting started with Sysand

Sysand is functional and ready to use today. Installation is straightforward: standalone packages are available for Windows, Mac, and Linux. At the moment, you’ll need basic command-line familiarity to use Sysand.

You can find more useful resources here:

• Sysand.org provides download links and installation instructions
• Sysand developer guide provides installation instructions, commands, and tutorials
• GitHub repository contains the source code and technical details

The source code is available for integration into any tool, commercial or open source, and contributions from the community are welcome.

As systems engineers explore package management for models, your feedback matters. What would make this approach useful for your workflows? What barriers do you see? This input will help shape Sysand’s evolution.

Takeaway:

• Sysand is functional today with standalone executables for all major platforms.
• At the moment, command-line familiarity is needed to use Sysand.
• Community feedback from systems engineers will shape its evolution.

Challenge for Tomorrow

Now it’s your turn to try Sysand in Syside Cloud:

1. Log in to Syside Cloud and open your workspace.
2. Create a new model interchange project using the Sysand integration.
3. Add dependencies from the public Sysand index at sysand.org.
4. Include one of your SysML v2 models from previous lessons.
5. Explore the commands: try sysand sources, sysand info, and browse the documentation to learn more.
6. Share your experience in the forum at Sensmetry Forum: What worked well? What challenges did you encounter? How could package management fit into your workflows?

Note: This challenge requires command-line familiarity. If that’s not your comfort zone, you can read through the documentation and share your thoughts on how package management could benefit systems engineering workflows.

Summary

In this episode, you learned about the challenges of managing and reusing SysML v2 models at scale, and how Sysand, the first open-source package manager for SysML v2 and KerML, addresses them. You explored how package management can support collaboration across distributed teams, integration with suppliers, organizational standards enforcement, and digital thread workflows.

This is infrastructure being built for the systems engineering community. Whether you’re ready to experiment with it today or simply understand its potential, you’re now aware of an important development in the SysML v2 ecosystem. The community’s feedback, especially from practicing systems engineers, will shape its future.

If you haven’t yet done so, head to Syside Cloud to engage with today’s challenge. Don’t forget to come back tomorrow for another episode of the Advent of SysML v2!