SysML-v2-Release: the OMG SysML v2 specification bundle in one repository

A document repository for a standard, not a modelling tool

The SysML v2 Release repository is described as the latest incremental release of the SysML v2 specification documents, example models and model library, and it also carries instructions for installing the SysML v2 Pilot Implementation editors. The repository description itself is blunt about where to start, and the README opens by pointing to it as the place to begin.

What that means in practice is that this is a bundle, not an application. There is no build to run, no test suite to pass and no service to start. The top level entries give the shape away: a doc directory for the specification PDFs and introductory presentations, an install directory with installers for the editors, then kerml, sysml, sysml.library, sysml.library.kpar, sysml.library.xmi and sysml.library.xmi.implied for the models and libraries, plus a bnf directory and an Eclipse project file with its .settings folder.

The primary language is listed as HTML, and the topic tags are mbse, sysml and systems-engineering. The maintainer is the Reference Implementation Working Group of the OMG Systems Modeling Community, a community for systems modeling end users, tool vendors and academia whose stated purpose includes acting as a bridge to the OMG Standard Development Organization process, feeding validated inputs into the specifications for KerML, SysML and the Systems Modeling API and Services, and supporting the building of other modeling languages and domain specific extensions on top of them.

For the engineer asking whether to use it, the judgement is simple. If you need to know what SysML v2 says today, or to obtain the normative libraries, this is the reference. If you want to model, you want one of the editors installed from the install directory.

The road from beta to formal adoption, and what changed in March 2026

The specification history in the README is a useful timeline for anyone working with SysML v2, because the language has moved through several states and older documents are still in circulation.

In June 2023 the OMG adopted three beta specifications, for KerML, for SysML v2 and for the Systems Modeling API, and those entered the OMG finalization process. The Reference Implementation Working Group then kept publishing incremental releases of the pilot implementation to support the finalization task forces. Once those task forces completed, the OMG published final beta versions of all three specifications.

The current versions are the ones to cite.

1. Kernel Modeling Language (KerML), version 1.0
2. OMG Systems Modeling Language (SysML), version 2.0
   - Part 1: Language Specification
   - Part 2: SysML v1 to v2 Transformation
3. Systems Modeling Application Programming Interface (API) and Services, version 1.0

As of 30 June 2025 these specifications have been formally adopted by OMG. The formal specifications were then updated editorially in March 2026 for submission to the International Organization for Standards.

That editorial update in March 2026 is the detail to note. An editorial update is not a semantic change, but it is also not a no-op, and it is the kind of revision that lands in a document you already cite without changing the version number. Anyone whose models depend on a precise clause should pull the current PDF rather than the copy from an earlier incremental release.

The install directory ships an Eclipse plugin and a Jupyter kernel

The install directory contains two installers, and they target different users.

The eclipse entry is an installer for Eclipse plugins for the Kernel Modeling Language and System Modeling Language editors. The jupyter entry is an installer for a SysML language kernel for Jupyter, with JupyterLab integration, and the README links to the Jupyter project for background.

The Jupyter option is the more interesting one for experimentation, because a language kernel means you can drive SysML v2 from a notebook environment rather than from a desktop modelling tool. That fits a lot of current practice, where models are written textually and versioned in the same repository as the code that consumes them. The text of the spec is itself textual notation, and the example models in this repository are textual too, so a notebook front end is a natural fit.

Two caveats on the process. First, the README does not document a command line install procedure for either installer, so a first-time user is expected to work from the installers themselves rather than from scripted steps; there is nothing here to copy into a Dockerfile. Second, the repository explicitly says that for developer installs you should see the development repositories, also available from the Systems Modeling organisation on GitHub. So this repository is for users, and the other repositories are for people extending the implementation.

Release notes live in the sibling repositories as well, with separate release streams for the pilot implementation, the API and Services, and the API cookbook, and there is a live OpenAPI documentation page that acts as an API front end to a prototype repository implementation.

The same normative library, shipped four ways

This is where the repository gets technical, and it is the part that trips people up. The normative model libraries for KerML and SysML in textual notation appear in several forms, and the differences are not cosmetic.

The sysml.library directory holds the libraries as textual notation. The sysml.library.kpar directory holds them packaged as KerML Project Archive files, which are containers of those textual notation files, and this is the form most useful if you want to import the library as a unit. The sysml.library.xmi directory holds the XMI representation, and the sysml.library.xmi.implied directory holds a second XMI representation.

The two XMI directories are the interesting pair, and the README explains the difference precisely. Both use Eclipse XMI files with the .kermlx and .sysmlx extensions, and the README states that this is not a fully normative OMG XMI representation. The difference is what is inside. The plain XMI is exported without derived property values or implied relationships. The .implied version is exported with derived property values and implied relationships.

That distinction has practical consequences. If a tool needs the implied relationships to be present, the plain export will silently give it a model that looks incomplete, and the failure will look like a modelling error rather than a choice of download. If you are writing a tool that computes those values itself, the plain export is the one you want, because you are not being handed derived values that may disagree with your own computation.

The model projects also include example models: kerml for example models in KerML, and sysml for example models in SysML v2 textual notation.

Three different licences live in this repository

The licensing section is more varied than the EPL-2.0 label on the repository would suggest, and anyone redistributing parts of this bundle needs to read it closely.

The repository itself is licensed EPL-2.0. But the specification documents are not covered by that. The README states that the specification documents are copyrighted by the organizations listed in those documents under the terms given there, so the licence for KerML 1.0, SysML 2.0 and the Systems Modeling API 1.0 is whatever the OMG terms inside each document say, not the repository's licence.

The two introductory presentations are a third case. The Intro to the SysML v2 Language-Textual Notation presentation is copyright 2019 to 2025 Model Driven Solutions, Inc., and the Intro to the SysML v2 Language-Graphical Notation presentation is copyright 2021 to 2023 Sandy Friedenthal. Both are licensed under the Creative Commons Attribution 4.0 International License.

Intro to the SysML v2 Language-Textual Notation.pdf
Intro to the SysML v2 Language-Graphical Notation.pdf

The README then addresses the Jupyter and Eclipse software and the included KerML and SysML v2 model content, but that paragraph continues beyond what is visible in the README as published here, so the terms for the software and the models should be read directly in the repository rather than inferred from the rest of the file.

The practical takeaway is that attribution travels with these documents. A CC BY 4.0 presentation requires credit, and the specification PDFs carry their own copyright and terms, so the safe pattern for a course, a paper or a conference deck is to cite the specific document and its version and leave the bundled copies out of your own distribution.

Monthly incremental releases, and a zip for the whole bundle

The release naming is dated by month, which tells you the cadence and the versioning model at the same time. The published releases are 2026-05 on 2026-07-22, 2026-07 on 2026-08-27 and 2026-08 on 2026-09-12, with the last push to the repository on 2026-09-12.

Two things follow. The first is that the label is a month, not a semantic version, so an incremental release supersedes the previous one and there is no long term support branch to point at. The second is the gap between the label and the publication date, which ranges from about seven weeks to eleven in the samples given, so the September release being published in mid September is the exception rather than the rule. If you are tracking the specification, a release can arrive a couple of months after the month it is named for.

The README gives the distribution route: for a zip archive of the entire repository contents, go to the releases page of the GitHub repository and download the appropriate version. That matters for anyone who wants the bundle as a single artefact rather than a clone, and it is the route to use when the goal is to hand a colleague a complete, dated set of documents and libraries.

The other content is not in this repository. Release notes for the pilot implementation, the API and Services, and the API cookbook are published in their own repositories, and the OpenAPI documentation for the current API implementation is served from a separate host at a port 9000 path, described as an API front end to a live prototype repository implementation. So the specification text and the libraries are here, while the implementation status is distributed across several places.

Where this repository will not help you

Three limits are worth stating plainly.

It is not an editor. You can model in it only by installing the Eclipse plugins or the Jupyter kernel from the install directory, and if your question is which modelling tool to buy, this repository answers a different question. The tools are the pilot implementation, which is a reference implementation rather than a commercial product, and the README points to tool vendors as part of the wider community the SMC serves.

It is not a source of implementation code. The primary language is HTML, and the repository holds documents, models and installers. Anyone who wants to modify the pilot implementation goes to the development repositories in the same GitHub organisation, and the README says so directly.

And the XMI export is not a normative OMG representation, which the README states twice with different consequences. If your pipeline depends on a canonical XMI from this bundle, you will be working with an Eclipse flavoured variant that omits, or in the second variant includes, derived values. Tooling that assumes the OMG representation will need a conversion step, and a lot of confusion in this space comes from exactly that assumption.

One more caution about the specification PDFs. The repository is updated as monthly increments, and the formal specifications were also revised editorially in March 2026 for ISO submission, so a document you cite should be checked against the current release and the OMG specification version rather than a copy cached in a wiki, a slide deck or a vendor's documentation.

Editorial conclusion

Adopt this repository as the source of truth for what SysML v2 currently says if you write models, build tools against the API, or train people on the notation, and you want the adopted text rather than a draft. Do not adopt it as an editing environment, since the editors are installers in the install directory and the development work lives in other repositories. Verify first that the release you read is one of the monthly incremental releases, that the OMG specification version behind it is 2.0 for SysML and 1.0 for KerML and the API, and whether you need the XMI library with derived property values, because the plain XMI export omits them and is explicitly not a fully normative representation.

Frequently asked questions

Official sources

1. Issues
2. License: EPL-2.0
3. README
4. Releases
5. Systems-Modeling/SysML-v2-Release on GitHub