Open source digital engineering

Open foundations for digital engineering.

OpenMBEE connects the tools, models and teams behind complex systems: a model hub to manage them, integrations to bring your tools in, and an open implementation of SysML v2, a central language for digital engineering.

How OpenMBEE's three pillars fit together MDKs are embedded in the tools engineers already use, such as Cameo, VS Code and Jupyter, and each MDK carries the OpenSysML runtime. The MDKs connect to MMS, the model hub, which holds SysML, RDF and OWL, and GraphQL interfaces. Cameo MDKsync · DocGen OpenSysMLSysML v2 · KerML VS Code MDKextension OpenSysMLSysML v2 · KerML Jupyter MDKkernel OpenSysMLSysML v2 · KerML MMS The model hub · version · branch · tag SysML RDF / OWL GraphQL REST & SPARQL APIs · access control

The platform

Three open pillars, one connected system.

Use them together, or adopt them one at a time. Each is open source and built to work with the others.

The hub

MMS

Model Management System

Version control for structured engineering data: branching, tagging, access control and open REST and SPARQL APIs, so every tool and team works from one source of truth.

Development integrations

MDKs

Model Development Kits

Tool integrations embedded where engineers already work, such as Cameo, VS Code and Jupyter. They sync models with MMS and generate documents from models with DocGen, with the OpenSysML runtime built in.

Language foundations

OpenSysML

Open source SysML v2

An open implementation of SysML v2 and KerML (parser, runtime, language server, notebook kernel and client libraries) built into the MDKs, so every tool shares a central, standard language for digital engineering.

Pillar 1 · MMS, the hub

One hub. Every model, version and tool.

Digital engineering means many tools and teams touching the same system definition. MMS is the layer that keeps them consistent, traceable and open.

⑂

Git for engineering data

Commit, branch and tag model data with full CRUD over a versioned repository, so you can see what changed, compare it, and return to any baseline.

⇄

Open, standard APIs

RESTful web services for model access. The Flexo architecture adds SPARQL and Graph Store Protocol endpoints, and a service implementing the OMG SysML v2 API.

⌘

Works with your tools

Desktop SysML clients like MagicDraw, the web-based View Editor, Mathematica, Python and Java clients, or anything that can call a web service.

❏

Documents and notebooks

Generate documents from models with the view and viewpoint approach, and store and search Jupyter Lab notebooks alongside the model.

◈

Graph-native models

Flexo MMS stores models as RDF graphs and can diff and manage anything expressible as RDF, not only a single vendor's model format.

⛨

Controlled and deployable

Access control and multi-tenant collaboration, LDAP-capable authentication in Flexo, and sample Docker Compose and Kubernetes deployments to run it yourself.

MMS architectures

Pick the MMS that fits your data.

Flexo is built for RDF graphs; Execubots is the long-supported JSON-document implementation. Flexo MMS is not a drop-in replacement for Execubots MMS.

Graph-native

Flexo MMS

Models as RDF graphs, with SPARQL and Graph Store Protocol endpoints for loading, updating and querying, plus management endpoints for orgs, repos and branches. Includes auth and store services.

  • Native RDF, graph diff
  • Flexo SysML v2 service (beta), an implementation of the OMG SysML v2 API Services Specification
  • Docker Compose and Kubernetes samples
Long-term support

Execubots MMS

Models as JSON documents behind RESTful web services for CRUD, branching and tagging, built from modular Spring components you can pick and choose.

  • Reference implementation (MMSRI) for a ready-made REST API
  • Jupyter notebook storage and search
  • Python client on PyPI (mms-python-client)

Pillar 2 · MDKs, development integrations

Bring your tools to the hub.

Model Development Kits are tool-specific integrations. Their primary purposes are to sync models with the MMS and to implement the DocGen language, which lets modelers dynamically generate documents from models using the view and viewpoint concept.

MDKs are embedded where engineers already work, such as Cameo, a VS Code extension and a Jupyter kernel, and they carry the OpenSysML runtime with them. Engineers keep working in the language and tool they prefer, while their work is versioned, shared and documented across other tools.

  • Sync with MMS

    Push and pull model data between your modeling tool and the versioned repository.

  • Documents from models

    DocGen turns model content into engineering documents, so documents stay current as the model changes.

  • Next generation: MDK2

    The OpenSysML Runtime Environment and Development Kit (REDK) is the second generation of the MDK, with a Cameo plugin in its repository.

Pillar 3 · OpenSysML, language foundations

SysML v2: a central language for digital engineering.

OpenSysML is an open source implementation of SysML v2 and KerML, written in Go. It gives tools, services and engineers a shared, executable definition of system structure, behavior and requirements.

⌥

Parser and libraries

A parser based on the OMG grammars, with the OMG standard library and OpenSysML extension libraries.

▶

Executable runtime

Instantiate parts, evaluate expressions with units, run actions and state machines, and check requirements.

>_

Command line and REPL

Model, execute and check interactively from the sysml command.

✎

Language server

Diagnostics, hover, go-to-definition, completion and formatting, with a VS Code extension.

❖

Jupyter kernel

Run SysML cells in notebooks alongside analysis and documentation.

⇆

Client libraries and service

Clients for Go, Python, TypeScript, Java, Rust, Julia and MATLAB/Octave, plus a gRPC service.

How it fits together

From language to finished deliverable.

  1. 1

    Describe

    Capture system structure, behavior and requirements in SysML v2, with OpenSysML tooling to parse, run and check it.

  2. 2

    Integrate

    MDKs and clients connect your modeling tools to the hub, keeping tools and repository in step.

  3. 3

    Manage

    MMS versions every change, supports branching and tagging, and controls who can see and edit what.

  4. 4

    Use

    Generate documents, run analyses, build apps and dashboards from the same governed data through open APIs.

Get started

Start with the piece you need.

Run an MMS hub on your own machine with Docker Compose, try the SysML v2 API service, or explore the OpenSysML runtime and language tooling.

# MMS: get the sample deployment files
git clone https://github.com/Open-MBEE/flexo-mms-deployment
cd flexo-mms-deployment/docker-compose

# then follow the quickstart for env configs and the init file

Around the platform

More from the OpenMBEE ecosystem.

SysML v2 Web Modeler

A standalone Java web service for SysML v2 graphical rendering and textual editing against a SysML v2 API backend.

OpenSE Cookbook

A compendium of best practices and lessons learned for performing engineering tasks with modeling languages and tools.

Toaster tutorial

An executable tutorial on recursive system decomposition with SysML v2 and OpenSysML.

In the wild

Proven on some of the hardest systems built.

MMS, View Editor and the MDKs have been used on JPL flight projects including Mars 2020, Europa Clipper, Europa Lander and Mars Sample Return, creating and maintaining hundreds of engineering documents from models with millions of elements.

The Thirty Meter Telescope SysML model is an industrial-scale application of OpenMBEE, used for system-level behavior simulation and state-dependent power and mass roll-ups, built with an extension of INCOSE's Object Oriented Systems Engineering Method (OOSEM).

Build the digital thread with us.

Anyone is welcome to contribute. There are regular meetings online and in person.