News

• Modelix Update 24.2
• Modelix Platform Release 24.1
• Modelix Update on XZ Utils Backdoor
• Modelix Roadmap Update 2024
• Modelix Platform Release 23.2
• First release of the new modelix platform 23.1
• Modelix Artifact Re-Grouping and Re-naming
• Modelix Update on JetBrain's Projector
• Modelix Update on Log4Shell
• Modelix Development Update 2021.1
• Modelix goes Open Source
• Modelix in the MPS Talk Series

Modelix Update 24.2

This article gives you an update on what happened in the Modelix project since the Modelix Platform release 24.1.

Firstly, we have decided not to release any more platform versions. There is so much development in between that we don’t want to encourage users to use outdated versions of infrequent releases of the platform versions. When you start using Modelix, get the latest versions of the components and keep them up to date. Our components use semantic versioning and changes are released on a daily basis.

We still want to keep you informed with blog posts like this. The following summarizes the highlights since the last update.

• Features
  • Model-Server: Support for authorization
  • Model-Server: Indices and Caching for ModelQL
  • Model-Server: View for changes between model data versions
  • Optimizations for bulk synchronization
• Improvements
  • Rework and stabilize API for Vue.js
  • Refactoring execution of ModelQL queries
• Experimental Features
  • Projectional text editors for the browser

Features

Model-Server: Support for authorization

You can now enable authorization on the model-sever to give users limited access to model data. You can limit a user’s access to specific repositories and branches or also specify whether they can only read data, write data or even rewrite the history of a repository.

The authorization requires JWT tokens that specify a user’s permissions in a specific claim. Such JWT tokens can be created by appropriately configured OAuth providers or by custom services.

Model-Server: Indices and Caching for ModelQL

To reduce the runtime of complex queries and to reduce resource consumption, indices and caching were built into ModelQL.

The following example shows how to cache the count of nodes that match a complex filter in ModelQL.

val countOfNodes = client.query { rootNode ->
   rootNode.memoize { rootNodeInner ->
       rootNodeInner.descendants(true).filter { it.someComplexFilter() }.count()
   }
}

Example for caching the count of nodes that match a complex filter in ModelQL

Model-Server: View for changes between model data versions

The model-server now provides a UI to explore changes between versions of data in a repository.

Optimizations for bulk synchronization

The synchronization of data from a model-server to MPS can now be done faster. When you know the version you synchronized to MPS the last time, you can now specify it as a base revision. In that case, the bulk synchronization utilizes efficient diffing between versions to only synchronize changed nodes.

Improvements

Rework and stabilize API for Vue.js

After incorporating user feedback, we declared the API Vue.js as stable and will avoid breaking changes.

Refactoring execution of ModelQL queries

To achieve better performance in ModelQL queries even without indices and caches, the ModelQL execution was refactored.

Experimental Features

Projectional text editors for the browser

Modelix is working on rendering projectional text editors in the browser.
For that an internal Kotlin-based DSL to define such editors was built and open sourced under the Modelix organization.

In June, the Modelix team gave a webinar about building modeling tools with Modelix. At the end of the webinar, those new components for web editors were demonstrated. You can request access to the recording on the website of itemis.

Modelix Platform Release 24.1

Version 24.1 of the modelix platform is out now! The platform is now independent of the MPS version and works with all supported MPS versions. Simply use org.modelix:platform:24.1.0 in your build scripts.

The versions bundled in this release are:

modelixCoreVersion = 7.3.0
incrementalVersion = 0.2.0
buildToolsVersion = 1.5.0
mpsPluginsVersion = 0.7.1

A more detailed list of the components is available here.

If you want to know how to use this platform in your Gradle build, check out the corresponding usage documentation.

• Feature Highlights
  • Support for newer MPS Versions
  • Stabilization of the Bulk Model Synchronization Plugin
• Experimental Features
  • MPS Sync Plugin (experimental)
  • New Adapter for the LionWeb Bulk API (experimental)
• What’s next

Feature Highlights

Support for newer MPS Versions

Modelix components are now compatible with MPS 2021.1 - 2023.2. To reduce the required maintenance effort, we decided to drop support for MPS 2020.3. While some use cases might still work with 2020.3, we highly recommend using a more recent MPS version.

Stabilization of the Bulk Model Synchronization Plugin

The bulk-model-sync Gradle plugin allows the bulk synchronization of models between MPS and a model-server. The plugin is now stable. However, we will continue to improve its performance in the future.

Experimental Features

MPS Sync Plugin (experimental)

A new Kotlin-based MPS Sync Plugin is in the making, which will allow you to bind local MPS repositories to remote model-server repositories. You will be able to seamlessly exchange model data between MPS and the model-server in an interactive fashion. Changes performed on one side will be automatically synchronized to the other side. For non-interactive workflows like CI tasks use the bulk-model-sync Gradle plugin.

New Adapter for the LionWeb Bulk API (experimental)

If you are interested in the integration of other modeling technologies than MPS then check out the LionWeb initiative (short for Language Interfaces on the web). The modelix team co-authored and is involved with LionWeb.

A first version of the lionweb-modelix-adapter has been made available on the LionWeb GitHub. It allows using the model-server with the LionWeb Bulk API, but comes with limitations detailed in the README. We recommend using the modelix model-api to make use of advanced model-server features such as real-time collaboration.

What’s next

Keep an eye on our new Modelix LinkedIn Page, where we are regularly sharing Modelix-related content including additional development insights.

Modelix Update on XZ Utils Backdoor

Modelix images are not affected by the XZ Utils backdoor (CVE-2021-44228).

Our images have versions of liblzma ranging from 5.2.2 to 5.4.1. So no image has the vulnerable version 5.6.0 or 5.6.1. Also, no image has an SSH server installed.

If you have any questions, feel free to reach out via the #modelix channel in the MPS Slack.

Modelix Roadmap Update 2024

Today we are excited to share our updated roadmap with you. It contains our current plans for major features in 2024 and beyond. We summarize the key priorities in a dedicated overview alongside more detailed explanations.

Please contact us if you have questions, want to discuss the key priorities and our plans, or seek technical support. We value your feedback!

Come find us over in the #modelix Slack channel or contact us via email.

Modelix Platform Release 23.2

We are happy to announce the autumn release of the modelix platform: 23.2

The versions bundled in this release are:

modelixCoreVersion = 3.12.1
incrementalVersion = 0.2.0
buildToolsVersion = 1.1.0
modelixMPSPatchVersion = 157

If you want to know how to use this platform in your Gradle build, check out the corresponding documentation.

• Feature Highlights
  • ModelQL
  • Model Client as NPM Package (experimental)
  • Vue.js Bindings (experimental)
  • MPS Model Adapters
  • Bulk Model Synchronization Plugin (experimental)
• Development Insights
  • New Approach to MPS-Related Components
  • Contribution Guide
  • Marking Experimental Features
  • Extending Automation
• What’s To Come

Feature Highlights

ModelQL

The ModelQL query language provides a dynamic way of loading parts of the model on demand while reducing the number of requests to a minimum.

Model Client as NPM Package (experimental)

The previously existing model client is now also published as @modelix/model-client NPM package.

The exposed API is minimal and experimental. In the future, we want to make more features from the Kotlin model client directly accessible from the exposed API in the NPM package.

Vue.js Bindings (experimental)

Built upon @modelix/model-client we created a library to interact with models through Vue.js.

With @modelix/vue-model-api we are currently building sample projects with Vue.js. After that, we want to stabilize the API and show you how you can use it for your projects.

MPS Model Adapters

We created adapters between MPS and modelix. They forward changes made to a model through the model-api of modelix to the Open API of MPS. They are compatible with all MPS versions that modelix currently supports.

With their help, it is possible to implement access and synchronization from modelix components to MPS. The bulk-model-sync Gradle Plugin is an example component that uses them.

Bulk Model Synchronization Plugin (experimental)

The bulk-model-sync Gradle Plugin allows bulk synchronization of models between MPS and a model-server. The plugin applies changes incrementally, and can be run in existing CI systems to schedule and run the synchronization in both directions. This way you can implement a custom Git Integration tailored to your needs.

The plugin is considered unstable, but will be stabilized soon.

Development Insights

New Approach to MPS-Related Components

Up until now, we built and released MPS-specific components for each MPS version individually. Going forward, we want to release single components, which are compatible with all MPS versions that are currently supported by modelix. The first component to follow this new approach is mps-model-adapters

To achieve that, we separate code in MPS solutions from support library code wherever possible. Also, we are developing upcoming MPS plugins as IntelliJ plugins instead of MPS plugins. This reduces the overhead required for updating and maintenance.

Contribution Guide

We created a contribution guide to help new contributors.

Marking Experimental Features

From now on, we mark experimental features clearly. You can read about it in more detail in our documentation

Extending Automation

In our automation, we introduced static code analysis, dependency updating and security checking. This aims to increase developer velocity, reduce bugs and provide more security for our users.

What’s To Come

We are in the process of planning our roadmap and are aiming to update it this year.

First release of the new modelix platform 23.1

We are very happy to announce the first release of the modelix platform: modelix-23.1

With many modelix components being in various development stages - from stable to early and conceptual - they are released individually for each repository. To make it easier for developers we now release a dedicated modelix platform twice a year unifying everything under a single version. This platform aggregates compatible modelix component versions. We aim to provide a Spring release and an Autumn release. All development in-between is carried out as patches on the releases if necessary. This release cycle starts from 2023 with the first release on the MPS Community meetup in May.

The versions that are bundled in this first release are:

modelixCoreVersion = 2.4.0
incrementalVersion = 0.1.4
buildToolsVersion = 1.0.11
modelixMPSPatchVersion = 145

If you want to know how to use this platform in your Gradle build, check out the corresponding Documentation.

The platform is published to the itemis Nexus as well as to GitHub Packages.

If you have any questions feel free to reach out via the #modelix channel in the MPS Slack or via mail.

Modelix Artifact Re-Grouping and Re-naming

In the last week we re-grouped and re-named several artifacts of modelix platform to more clearly convey their functionality. For example, the metamodel-generator is now named model-api-gen illustrating the fact that it generates a model API. Additionally, we also added correct Gradle plugin markers to ease the usage of Gradle plugins in your build scripts. We also bumped the major version of all modelix core components to indicate the breaking nature this group and name change.

The following table lists all current artifacts, highlighting the changes we made in bold text.

In case you are not on the latest modelix version, we encourage you to wait just a little bit longer - we are in the process to transition to a bi-yearly release cycle. The first release 2023.1 is planned to be launched with the upcoming MPS Meetup 20203. As a part of this we also plan to provide further documentation on the most important modelix platform components. Stay tuned!

If you have any questions feel free to reach out via the #modelix channel in the MPS Slack or via mail.

Modelix Update on JetBrain's Projector

On March 11 2021 JetBrains announced the initial release of Projector. It can be used to run JetBrains IDEs and Swing apps remotely over the network. Just recently JetBrains announced the suspension of Projector as its own standalone product. There are components in modelix which make use of Projector so consequently the question arises how this change affects the support in contexts such as Modelix?

This announcement by JetBrains might seem rather sudden. In fact, two client implementations for Projector exist, a browser based one (the now discontinued Projector) and a dedicated one called Gateway. The browser based one has some limitations and Gateway provides the better experience (for our use cases the browser limitations are not relevant, because we do not want the full IDE experience anyways). That’s the reason why JetBrains decided to discontinue developing the browser based one.

From the perspective of modelix this announcement does not pose any problems. At the moment we simply use projector for embedding MPS editors into the browser and it is not our long term goal to keep it this way. We will be replacing these embedded editors by editor implementations that use HTML/JS and provides a better integration with other web frameworks.

However, connecting to a remote MPS instance via managed by the server might still provide some benefits for language developers, but then the solution for this use case is to have a provider plugin for Gateway instead of using the browser based Projector. For now, Projector still works and is still better than our own attempts at providing a similar feature. If needed we can even maintain a fork for the transitional period.

If you have any questions feel free to reach out via the #modelix channel in the MPS Slack.

Modelix Update on Log4Shell

A short update on the vulnerability called “Log4Shell” (CVE-2021-44228) from the modelix team:

As you most likely have heard already there is a vulnerability in the popular logging framework log4j affecting many projects, especially services logging HTTP requests. For more details on the vulnerability see the log4J announcement.

Since modelix services can face the public internet you might ask yourself if you are affected when running modelix. The good news is you are not affected by Log4Shell when you are using modelix. Modelix doesn’t use the particular versions on log4J that are vulnerable.

As part of a review of our dependencies we discovered that we are in fact using log4J 1.2.17 which isn’t affected. But log4j 1.x is end of life since 2015 and doesn’t receive further updates. We mitigated this by replacing log4j with logback in the places where we used it. Logback is a well maintained log4j API 1.x compatible open source project. As of now we do not think any version of modelix in its default configuration is vulnerable to the known issues of log4j 1.x. The issues are affecting the SocketServer and could result in remote code execution. The modelix default configuration does not load these classes.

A Note on MPS

Modelix depends on MPS for the browser based MPS editor and via projector. MPS and other IntelliJ based products from JetBrains aren’t affected by Log4Shell. MPS and the IntelliJ Platform are using log4j 1.2.17 at the moment. Similar to modelix their default configuration does not expose the vulnerable parts of log4j.

JetBrains is actively working on replacing log4j 1.x.

If you have any questions feels free to reach out via the #modelix channel in the MPS Slack.

Modelix Development Update 2021.1

This is the first post in a regular series where we will give an update on modelix development. In this first post we will look at what happened in modelix since the open source announcement by itemis last year.

MPS 2020.3

Modelix is now based on top of MPS 2020.3 and supports projects using the latest MPS version. You might wonder why 2020.2 was skipped? We encountered problems during the migration to 2020.2 which were supposedly fixed in the code was designated to become MPS 2020.3 and we decided to skip this version.

Native HTML Editors

While modelix features a “picture based” editor for existing MPS languages from the very beginning, modelix is also working on editor implementations that are native to the web.

One of such editor implementations is the “web aspect” and the “modelix.notation” language. Right now these editor definitions are focused on textual editors that render directly in the browser using HTML. The HTML for the editor is rendered on the server and then send to the client. Updates to the editor are also rendered on the server and the affected HTML is updated on the client side.

The implementation is not feature complete yet but should give you a good impression what’s to come in the future.

Modelix at MPS Talks

At the MPS talk series, an online event organized by itemis and JetBrains, Sascha presented modelix. The presentation includes a live demo of the collaborative features and a detailed explanation on how conflicting edits are handled as well as an overview on the modelix architecture. Check out the recording the blog post.

Project Bindings

After many smaller contributions Federico has made a large contribution improving the interoperability between modelix and MPS.

Project bindings allow you to configure connections to a modelix backend inside of your MPS project and persist this configuration. While connections to a modelix repository where always possible, they were never persisted as part of the project. The configuration is now stored as a file along with the rest of the MPS project and can be committed as part of your normal version control workflow.

Project bindings are the bases for uses cases where existing models are easily migrated into modelix by an end user.

Modelix goes Open Source

Modelix in the MPS Talk Series

Modelix came public for one of the very first time last February in the first virtual MPS Talk Series organized by Jetbrains and itemis. In one of the most antecipated talks Sascha Lisson gave us an overview of Modelix and its capabilities.

Other Recordings

All of the recordings from this event are also available in the Jetbrains website.