How to debug in MPS

The quickest way to start debugging in MPS is the following:

We are using com.dslfoundry.plaintextgen as an example.

Please be advised that in (possibly earlier) generic distribution versions of MPS, the debugger doesn’t work. You will have to really use one of the dedicated distributions (Mac, Linux, or Windows).

  • Choose your breakpoint by clicking in the gutter:


  • Select Run –> Edit Configurations from the main menu:


  • Press + to choose from the list of new configuration types to add:


  • Choose MPS –> MPS Instance:


  • Check Open current project:


  • Type your own name for the run configuration (I chose MPSInstance):


  • Press OK to close the Run configuration screen and then select Run –> Debug MPSInstance from the main menu:


Now a second instance of MPS will be started (click away all the startup screens that come in).

With the given breakpoint, let’s inspect variables:

  • Trigger the code with the breakpoint by executing the Surround with Horizontal Collection intention:mps-debugging-8
  • Now the MPS instance is going to freeze, because the debugger paused it at the breakpoint. Go back to the original MPS window from where you started the debug session and view variables:mps-debugging-9

Tip: enable toolbar for having convenient debug buttons. You can do this by selecting View –> Toolbar from the main menu.

How to build mbeddr on Windows

This howto describes how to build the mbeddr sources from scratch on Windows.

If you are looking on how to build an mbeddr or mbeddr platform-based app, please see the mbeddr build guide.

In this howto, I built mbeddr nightly 380 for JetBrains MPS 3.4.3 on Windows 7 using Oracle JDK 1.8 update 121 (see the JDK Oracle archive if the link is not available anymore), ant 1.9.7, and mingw32 (also install msys along with it and select the pthreads dev package).

A warning to those who want to use OpenJDK instead of Oracle JDK: the mbeddr build uses gradle, which needs keys for the gradle and mbeddr service repositories in the trust store. You can try this solution to add the necessary keys from the servers in the URLs of gradle and mbeddr that go wrong, but I chose the easy route and used Oracle JDK, which is anyway recommended with JetBrains MPS, the platform on which mbeddr is built.

Start first by checking out the mbeddr.core repository and checking out the nightly-380 tag:

> git clone
> cd mbeddr.core
> git checkout nightly-380-MPS-3.4.3

Before starting to build, don’t forget to put javacant, gcc, and make in your PATH and all the java platform jars in your CLASSPATH, either in your global/local environment variables, or directly on the shell before compiling. I did it on the shell:

> set PATH="C:\Program Files\Java\jdk1.8.0_121\bin";%PATH%
> set PATH=C:\app\apache-ant-1.9.7\bin;%PATH%
> set PATH=C:\app\mingw32\bin;C:\app\mingw32\msys\1.0\bin;%PATH%
> set CLASSPATH="C:\Program Files\Java\jdk1.8.0_121\lib\*.jar";%CLASSPATH%

Then you only need to tell gradle to do its job:

> gradlew build assemble

If you also need to use your locally built version of mbeddr for other builds on your local machine that depend on it, you can run this command to put it in the local Maven cache:

> gradlew publishMbeddrPlatformPublicationToMavenLocal

Thanks to  Sergej Koščejev and Kolja Dummann from the mbeddr team for the hints and tips to get the build running.

How to write a dump of an MPS model to XML based on its structure

This post has been written using material developed in JetBrains MPS 3.3.5. The example project can be found at DSLFoundry’s MPS example github repository under StructureDumpToXML. It is recommended to have this project opened while going through this howto.

Suppose you want to dump a model to some simple XML format without wanting to write a generator or wanting any specific knowledge about the structure of the model. A use case for this could be that you don’t want to have to make changes in the generator for a simple XML dump, just because you change the structure. Now of course this can be solved using custom persistance, but let’s say you just want something quick and simple without having to deal with too much of the more complicated stuff like references. This howto shows such a simple case. So here we go:

An example model:


Let’s use the generator mechanism and the xml language from JetBrains to make an XML dump out of this:

  • make a root mapping rule, by double clicking on the generator’s main, then click on root mapping rules and press enter:


  • choose MyConcept in the input concept:


  • import the xml language by pressing Ctrl+L+L (yes, you have to press L a second time) and then choosing it:


  • stand on the template of the root mapping rule and press Alt+Enter to invoke the intention menu and choose New Root Template, then choose directly xml file:

2016-10-27-13_04_43-structuredumptoxml-d__repo_dslfoundry_mps-examples_structuredumptoxml-_ and then:


  • navigate to map_MyConcept by Ctrl + clicking it:


  • add an XML element using the completion menu:


  • call the element something (e.g. bla) and create a MAP_SRC macro which makes it possible to build any wild mapping construct you’d like:

2016-10-27-14_34_45-structuredumptoxml-d__repo_dslfoundry_mps-examples_structuredumptoxml-_ and then:


  • now go to the inspector of this MAP_SRC macro by clicking the macro and pressing ALT+2:


  • go to the <none> part of the mapping func and then press Enter to create a mapping function:


  • from this point on, you can type baseLanguage code, which is pretty much the same as typing java. We replace the XML element <bla></bla> with a new XmlElement node that we create, using some regular programming. See the next step first to see how to create the dumpStructure funciton so that you can call it here in the macro. The code you see is a combination of baseLanguage and smodel language. The MPS smodel language makes it possible to query a model and build nodes. For more information on this, see the MPS smodel reference:


  • in the above piece of code, we use a piece of behavior that belongs to a helper aspect called StructureDumper. This code can be created by making a concept called structure helper and then making a new behavior for it:


  • now we can type the code for the dumpStructure function. This is just a recursive function reading the model and dumping everything to XML. Note: in the statement mpsNode/.getProperties(), there is this strange notation mpsNode/. This is a so-called semantic downcast operation. It makes it possible to reach directly the java class that encode the node mpsNode (needed here for reflectively reaching its properties).


  • since the XML language has a text generator and we hooked the transformation from our model to XML in a MAP_SRC macro of a generator, we have text generation. You can preview the text by right-clicking the model called myconcept in the StructureDumpToXML solution and selecting Preview Generated Text:


  • and the text will look like this:


  • note that nothing smart has been done yet with references. This is tricky, since we may get (even indirect) circular references.

This howto has demonstrated the use of MAP_SRC macro to do a dump of an arbitrary (at least for simple cases where it’s a tree) MPS model to an XML format of your own choosing. Feel free to extend and improve for your own needs. We may one day make a language that will just do this automatically.

If this post helped you, gave you ideas or has motivated you to help, please feel free to contact us on github.

Extra tips:

  • if you need special characters properly escaped as XML entities in MPS 3.3.5, it is recommended to use mbeddr’s com.mbeddr.mpsutil.xml.fix language.
  • you may need to use light quotations instead of the manually written code for node instantiations in the above described dump function (see JetBrains docsite on light quotations). The reason that you cannot use full quotations is, I think, because you may not have all the editors built before building behavior, which makes it impossible to have the editor to make a full quotation.

How to add default to a property in a concept

This post assumes that you have an MPS with mbeddr preloaded.

Go to the constraints aspect for the concept you want to add a default to a property:


Create a new constraint for this concept:


Press Ctrl+L and import the language com.mbeddr.mpsutil.propertydefault:



Go to the property constraints and press Enter to make a new one:


Choose the property to which you want to apply a default value:


Select the entire constraint by pressing ctrl + uparrow twice:


Press Ctrl + Space and choose default to convert the constraint to a default specification:


Choose your default value:


If you now make an instance of MyConcept, you will automatically get the myProperty filled in with the default value:



First pre-release of mps-textgen-multilanguage plugin

This plugin enables you to use the standard template mechanism of MPS (node macros, loop macros, property macros, etc.) to generate free text. So if you have some custom text format you want to generate to, you will have a more easy and useful mechanism than the standard MPS textgen.

Please see the mps-textgen-multilanguage github page for more details.

Download: mps-textgen-multilanguage first release tag.

Where are mbeddr builds located?

Go to the mbeddr build page.

Login as guest (username: “guest”, password: “guest”) and then go to Build –> the plugin you want to download (e.g. sl-all) –> branch you want to download from.

Then choose Latest successful build –> Artifacts –> Download all (zip)

See picture below for the example of the sl-all plugin



Welcome to DSLFoundry!

Here we create and collect tools and libraries for Domain Specific Languages (also see about). You can see these on our projects page.

In addition, we will post some handy tips about DSL tools now and then in the posts further down this blog.

Please feel free to reuse our code and if you find bugs, please let us know via one of the github issue trackers. And of course you are welcome to contribute if you have any additions or enhancements.