arXiv CSopen access

Connecting the Models: A Global Mega-model of MDE Projects on GitHub

Connecting the Models: A Global Mega-model of MDE Projects on GitHub Jesús Sánchez Cuadrado∗ [email protected] Universidad de Murcia Murcia, Murcia, Spain

arXiv:2606.29606v1 [cs.SE] 28 Jun 2026

Abstract A key element of Model-Driven Engineering is the construction of domain-specific modelling environments to improve productivity and quality. In theory, dedicated technologies like EMF, ATL, Epsilon, Xtext, etc. would boost the construction of high-quality environments with a relatively modest effort by chaining the output of one tool to the input of another. However, there is little empirical evidence of how this idea has fared in reality and many open research questions remain, such as how MDE tools are used and combined, whether the resulting environments are maintained or not, which tools are used more frequently, etc. In this paper, we aim to build a foundation for studying how MDE is used in practice. First, we constructed a dataset by mining 7,436 Github projects comprising over 325,000 MDE artefacts. These artefacts encompass representative Eclipse EMF-related technologies, namely Ecore, Emfatic, OCL, ATL, Epsilon, QVTo, Henshin, Acceleo, Xtext, Emftext, GMF and Sirius. We also integrated into the dataset repository-level information extracted from the Git repositories and the GitHub API. From this dataset, we devised a technique to recover the mega-model of each project in order to represent the relationships between its artefacts. Then, we built a global mega-model relating the different MDE projects by performing an analysis of near-duplicates across all artefacts and grouping duplicate artefacts into single nodes and rewiring the connections. This global mega-model can be used to derive additional information like inter-project dependencies or studying connected subgraphs of artefacts. Finally, we propose a number of research questions that could be answered with the provided dataset, which we hope will foster empirical analysis of how MDE is applied.

CCS Concepts • Software and its engineering → Model-driven software engineering; Software libraries and repositories.

Keywords Model-Driven Engineering, Mega-model, Dataset

1

Introduction

At the beginning of the century, the Model-Driven Engineering (MDE) paradigm was considered a promising approach to software development, with the potential to revolutionise the way software was built. MDE promised to deliver productivity gains by relying on software models throughout the development process. Such models would be specified and managed by developers Uploaded to arXiv, 2026.

using domain-specific modelling environments (either based on general purpose modelling languages like UML or based on DomainSpecific Languages). Therefore, a key aspect was how to develop these environments by creating (or reusing) model transformations, code generators, validators, simulators, etc., using dedicated technologies like EMF for meta-modelling, ATL and Epsilon for model transformations, Xtext for textual syntax, etc. The end goal was to raise the level of abstraction, and improve automation (e.g., generating code) and quality (e.g., by having domain-specific validation). Twenty years later, a key question for the software engineering community, and particularly for the modelling community, is whether MDE has fulfilled its promises and, if not, to have insights about the current state and what may have failed. Some works have studied the impact of MDE in industry, showing that MDE can be applied succesfully in narrow domains [15, 18]. Other works have analysed open source projects to study the usage of specific types of files, like Ecore meta-models [3, 7] and Xtext grammars [30], and UML models [24] and BPMN models [5, 25]. However, to date, there have not been any works which have analysed complete MDE projects “in the wild” or focused on the relationships between the different artefacts that comprise them. This work aims at providing the basis to study how MDE tools are built by realising a large-scale analysis of modelling technologies in GitHub. To perform such analysis we have mined GitHub to identify potential MDE projects and we have collected relevant MDE artefacts. This first phase has yielded a raw dataset of 7,436 Github projects and 327,762 artefacts accompanied by stats extracted from the Git repositories and the GitHub projects. From this dataset, an analysis is performed based on reverse engineering such projects in order to recover their underlying project mega-model (that is, the relationships between the project’s artefacts). Then, the recovered mega-models are merged into a global mega-model which represents potential relationships between projects. This process is supported by dedicated algorithms to analyse near-duplicates across artefacts. All of this is assembled into a mega-model dataset which provides several levels of information: project-level megamodel, inter-project relationships and a global mega-model graph. In addition, we have built an interactive tool to explore the data. We also show the usefulness of the datasets by providing an initial set of research questions which could be addressed. Altogether, this paper makes two main contributions:

(1) An end-to-end methodology to construct a global megamodel to study the relationships between MDE artefacts. The practical construction of a complete mega-model of publicly available MDE artefacts of such a scale had not been achieved so far.

Uploaded to arXiv, ,

(2) Two datasets readily available to perform empirical studies on public MDE projects, named ModelGraph The datasets are supported by a web-based tool to explore the megamodel, as well as databases and a set of APIs to access it. The goal is to enable other researchers easily experiment with this data. This is available at https://models-lab.inf.um.es/ files/modelgraph-dataset/ and https://models-lab.inf.um.es/ modelgraph-ui/. Organization. The rest of the paper is organized as follows. In Section 2, we motivate the paper through a running example, discussing some challenges and presenting a quick overview of the approach. Then, Section 3 describes the construction of the raw dataset and Section 4 presents the construction of the global mega-model. Section 5 shows the supporting tools while Section 6 presents a critical assessment and discusses several research questions which can be answered with this contribution. Finally, Section 7 presents related works and Section 8 concludes.

2

Motivation and process overview

Many technologies have been proposed to enable de construction of domain-specific modelling environments for and with MDE. A core element is the use of standard meta-modelling frameworks (like EMF, SDF3, MPS Structure Language) which provide a common formalism around which other tools and meta-tools can be built. In particular, in the EMF ecosystem, many meta-tools have been proposed which target different concerns of the construction of modelling environments. In contrast to integrated language workbenches like MPS or Spoofax, a MDE tool built on top of EMF will use different meta-tools for its construction and possibly custommade solutions for their integration. Thus, typical configurations include the use of language creation tools like Sirius or Xtext to define editors, model validation with OCL or EVL, model transformations with languages such as ATL, ETL, QVTo, etc. and code generation with languages such as Acceleo, EGL templates, etc. Therefore, a modelling project contains many artefacts conforming to different MDE-specific languages (ej., Ecore, ATL, etc.). From now on we will refer to this kind of files as MDE artefacts. In theory, the combination of these tools would result in highquality environments, built with moderate effort. However, there is little empirical data to assess whether this claim is true or not and how MDE tools are used to build modelling environments. This lack of empirical data has left many research questions about MDE open. Some of the questions are described in Sect. 6.3, like what has been the evolution of MDE projects in time?, are MDE projects actively maintained?, how developers reuse MDE artefacts?, do developers build transformation chains?, etc. This work aims at addressing the gap in the knowledge of how MDE artefacts are used in public projects by realising a large-scale analysis of MDE technologies in GitHub. In this work we focus on the EMF because it is widely used and its lack of integration presents a wide range of challenges. We leave the application of our method to other systems like MPS or Spoofax as future work.

2.1

Running example

As a running example, let us consider three concrete GitHub projects. § utwente-fmt/attop is a research tool for analysing attack trees,

J. S. Cuadrado

§ upohl/mechatronicuml which is a fork of a tool for designing and analysing mechatronic systems, and § fraunhofer-iem/uppaalmodel which is a wrapper for Uppaal based on EMF. Fig. 1 shows some of the files in the projects.

utwente-fmt/attop/[…]/UATMM2Uppaal.etl

utwente-fmt/attop/UppaalEMF/[…]/uppaal.ecore

import "stdfunctions.etl"; rule Base transform at : UATS!AttackTree to out : Uppaal!NSTA { for (node : UATS!Node in at.Nodes) {…} out.int = new Uppaal!PredefinedType(); out.int.name = "int"; }

<ecore:EPackage xmi:version="2.0" name="uppaal" nsURI="http://www.muml.org/uppaal/1.0.0" <eClassifiers xsi:type="ecore:EClass" name="NTA" eSuperTypes="#//core/NamedElement"> … Links transformation to meta-model <launchConfiguration …> <stringAttribute key="source“ value="UATMM2Uppaal.etl"/> <listEntry value="metamodelFile=/attop/[…]/uppaal.ecore"/>

fraunhofer-iem/uppaal-model/[…]/ DiagnosticTrace.text

fraunhofer-iem/uppaal-model/[…]/uppaal.ecore

grammar org.muml.uppaal.trace.DiagnosticTrace import_"platform:/resource/org.muml.uppaal/ model/uppaal.ecore" as uppaal generate trace "http://www.muml.org/uppaal/trace/1.0.0"

Generates an Ecore TraceRepository: (traces+=Trace)* ; upohl/mechatronicuml/[…]/MUML2UPPAAL.qvto

<ecore:EPackage xmi:version="2.0" name="uppaal" nsURI="http://www.muml.org/uppaal/1.0.0" <eClassifiers xsi:type="ecore:EClass" name="NTA" eSuperTypes="#//core/NamedElement"> <eAnnotations source="http://[...]/OCL"> <details key="UniqueTemplateNames" value="self.template->isUnique(name)"/> </eAnnotations> Not present in

import transforms.lib.MUML2UPPAAL.Clocks; modeltype uppaal uses 'http://www.muml.org/uppaal/1.0.0';

attop/uppaal.ecore

transformation MUML2UPPAAL(in original: muml_rtsc, out output: uppaal);

Figure 1: MDE artefacts in different GitHub projects.

Project attop includes the UATMM2Uppal Epsilon transformation from a custom meta-model (UAT) to the Uppaal model checker. To do this, the project made a copy of uppaal.ecore published in some other GitHub repository. It might be the case that it came from fraunhofer-iem/uppaal-model since it to publishes an Uppaal wrapper for EMF (actually, this is a fork of uppaal-emf/uppaal). It is worth noting that both files of the Uppaal meta-model are not identical but have evolved independently. In this case, we show an excerpt of the fraunhofer-iem/uppaal-model version which includes OCL constraints not present in attop’s. At the same time, upohl/mechatronicuml is based on QVTo, among other technologies, and also targets Uppaal. Our goal is to recover the relationships between the artefacts that make up MDE projects and to build a global mega-model to explore them. However, there are several challenges which make it difficult to systematically perform such an analysis. First, the plethora of MDE technologies makes it difficult to build a simple and uniform analysis pipeline since each MDE tool is different and the way it refers to a meta-model or to other artefacts differs. Moreover, there is generally not a standarized project organization. Thus, we need to build specific analysers for each considered technology and be broad about the project organizations. Second, the relationships between artefacts are many times implicit in the sense that are not directly declared in the MDE artefacts. For instance, an Epsilon program (see example) does not declare its meta-models. Instead, this information needs to recovered from other sources like configuration files (in the example, an Eclipse launcher contains information about which meta-model corresponds to the transformation). Third, in MDE projects dependencies are rarely handled systematically, but by copy-pasting and adapting artefacts. In the example, this is evident by the fact that the attop project solves it needs to target Uppaal by copy-pasting resources from another project.

Connecting the Models: A Global Mega-model of MDE Projects on GitHub

2.2

Process overview

To tackle the aforementioned challenges, we propose a systematic method to mine MDE projects, recover their implicit mega-models and combine them into a global mega-model. The process we have designed have two main steps: (1) extracting and analysing the raw MDE artefacts and (2) building a global mega-model. In the first step, we work at the file and repository levels to extract the raw data. We use the GitHub API to find relevant MDE artefacts and projects, then we clone them locally to extract the actual list of MDE artefacts as well as to extract useful statistics. The collected data is gathered into the raw dataset. This is described in detail in Section 3. In the second step, we apply specific algorithms and strategies to recover the relationships between the MDE artefacts. The process starts from the raw dataset, considering only those projects with at least one MDE artefact. It follows three main steps (which are described in detail in Section 4): (1) Recover artefact dependencies. From the raw dataset we traverse the MDE artefacts described in Table 1 and analyse them one by one. The goal of the analysis is to recover the direct relationships of each artefact individually. For instance, to which meta-models it conforms to, which artefacts imports, what does it generate, etc. This is discussed in Section 4.1. The output of each artefact analysis is a so called “artefact graph” representing its recovered relationships. (2) Project-specific merging. In this step we merge all artefact graphs in a given repository so that we can build a mega-model of the project. The merging strategy is described in Sect. 4.2. (3) Build mega-model graph. Finally, we merge all graphs into a unified, large scale megamodel. This is done by first computing near-duplicates among all artefacts, and then using such duplicates to identify “merging points” for the project-specific graphs. This is described in Section 4.3.

3

Building the raw dataset

In this section we describe the methodology followed to build the raw dataset, that is, a dataset which is solely based on modeling artefacts collected from GitHub, without further processing to analyse its contents.

3.1

Data collection

The first step was to setup a mining process to crawl GitHub and collect the relevant data. It had the following steps: (1) Collecting individual MDE artefacts. We started by identifying relevant types of MDE artefacts (see Section 3.2), for instance Ecore meta-models, ATL transformations, etc. We use the GitHub API to search for files with extensions related to such artefacts of interest. For each artefact type we have defined a GitHub query string which includes a piece of text that always appear in the corresponding artefact. This allows us to filter out most files with the same extension but not belonging to the MDE technical space. For instance, we search for .ecore files containing the EPackage text as a hint that it is actually a meta-model. In addition, to overcome the API limit, we split the searches by size ranges, so that we iteratively move a sliding

Uploaded to arXiv, ,

window (e.g., files with sizes between 128Kb and 256Kb) until no files are found in several iterations. (2) Handling missing repositories. After manual inspection, we found out that some MDE artefacts which can actually be found in GitHub were not in our list. The reason is that GitHub is no longer indexing repositories1 with no activity within one year. This means that the results of the previous step may be missing some historical data. To alleviate this, we perform two actions. First, we have carried out three crawling steps, in February 2022, May 2025 and the last one in March 2026, so that the chances of missing a repository are reduced. Second, we have also considered the files crawled from GitHub by the MAR dataset [20] for Ecore and Xtext which were crawled in 2020, before GitHub introduced the policy and therefore guarantee the inclusion of historical repositories. (3) Cloning repositories. From the retrieved files, we derive the set of GitHub projects which contain MDE artefacts. Then, we download all of the repositories to form our dataset. The goal is to make sure that we recover complete MDE projects. This two-step approach has two advantages: (1) it allows us to make sure that we do not miss any artefact not crawled in the first step, and (2) by downloading the repository we gather complete information about the project (i.e., the Git history). (4) Discovering artefacts. All downloaded repositories are traversed collecting the files which fits the artefact type extensions described in Table 1. In this traversal we perform another, more aggresive content filtering step to rule out files which might have been wrongly crawled due to limitations in the GitHub API. For instance, extension cs used by EMFText is shared with C# files, which means that any C# file containing the string “SyntaxDef” was included in the original file list. So, we filter out any cs file not containing several common EMFText tokens like (RULE and ::=). In addition, we use this pass to collect the creation and last update dates of each artefact. (5) Collect repository-level information. We use two sources to collect repository-level information: a) the GitHub API to retrieve community-related information like project description, stars, forks, etc., and b) the Git repository itself in order to collect information like last update, etc. The final result of this process is a database, named raw dataset, whose relational schema is shown in Fig. 3. It contains the set of MDE projects along with the list of MDE artefacts (File). The Gitlevel information for the repository includes the contents of the README, the number of files in the repository, the date of the last update and some simple stats like the total number of commits. The information related to the GitHub repository contains all the information available from the GitHub API, such as the parent repository (if it is a fork), the number of issues, stars, forks, etc. At the artefact level we record the type of files (which is different from the extension since for example for Epsilon we consider 7 types of extensions) and also the creation date (by looking at the first commit that created the file) and last update. Finally, we keep a private copy of the repositories downloaded in March, 2026 which we use to analyse the contents of the files in the mega-model recovery step. 1 This

is briefly described in this GitHub’s announcement https://github.blog/changelog/2020-12-17-changes-to-code-search-indexing/.

Uploaded to arXiv, ,

J. S. Cuadrado

Modelling repositories

Artefacts by type per repo.

Recover repository info.

Clone repositories

Find artefacts GitHub Search API

Identify artefacts

Project graphs

Artefact graphs

GitHub Repository API

Recover artefact dependencies

Global graph

Project-specific merging

Raw dataset Modelling repositories

Find duplicates

1 Raw dataset construction

Build global mega-model Mega-model dataset

Artefact clusters

2 Mega-model construction

Figure 2: Method to build the mega-model of MDE artefacts from GitHub repositories.

MDEProject project_path

1

GitRepository

GitHubRepository

readme_contents number_of_files total_commits commits_per_month last_update

name full_name parent_repo description total_issues total_prs stars watchers forks subscribers topics labels created_at contributors_count contributors_list

*

File file_path filename extension type created_at updated_at

1

Figure 3: Schema of obtained information.

3.2

Table 1: Artifacts types considered plus some statistics. Column Count shows the total number of artefacts of each type, Project ocurrences reflects the percentage of projects with at least one artefact of the given type and Uniqe indicates the total number of unique files (i.e., after deduplication). Tool

Purpose

Count

Project Ocurrences

Uniqe

Acceleo

Codegen

17,664

8,98%

8,298 (46.98%)

ATL

Transformation

9,850

7,25%

2,460 (26.60%)

Ecore

Metamodel

199,025

93,37%

31,099 (15.27%)

Emfatic

Metamodel

2,402

5,98%

1,475 (62.90%)

Emftext

Syntax

1,442

1,00%

415 (93.05%)

Epsilon

Transformation

14,234

7,42%

6,608 (49.04%)

GMF

Syntax

1,280

5,62%

656 (51.25%)

Henshin

Transformation

52,158

1,51%

7,755 (14.87%)

OCL

Validation

8,801

4,94%

4,360 (50.29%)

QVTo

Tranformation

8,380

3,63%

2,109 (25.29%)

Sirius

Syntax

4,307

8,85%

1,415 (32.87%)

Xtext

Syntax

8,219

41,41%

3,995 (48.93%)

-

-

Artifact types

In this work we have considered 12 types of MDE artefacts. Table 1 summarizes them, including data about number of artefacts, the percentage of ocurrence in projects and the number of unique files. This data is discussed in Section 6. The selection of these artefacts is based on the following criteria: they must be EMF-based artefacts (that is, compatible or directly built over EMF), they must be well-known tools by the community and it should be possible to find a non-neglible number of artefacts in GitHub and finally, it must be feasible to download and analyse the artefacts. As an example of discarded artefacts, we have no considered in the current version of the dataset well-known artefacts like VIATRA queries since the language has undergone non-compatible changes and our manual queries in GitHub have shown that there are little artefacts of each version in GitHub (i.e., discarded due to the availability criteria). Another example are Xtend templates. While it is technically possible to include them, it is not clear how to identify automatically which are the source meta-models targeted by the templates (i.e., discarded due to the analysability criteria). We have also considered two types of “build artefacts”: Eclipse launchers and Ant builds. They are useful in the mega-model recovery phase to identify artefact relationships which are encoded as configurations instead of directly in the artefacts.

Eclipse Ant file

4

Total artefacts

327,762

Launcher Build

29,077 16,781

Total configs

45,858

A mega-model of MDE in GitHub

The raw dataset is already a valuable resource to study different aspects of MDE (see Sect. 6.3). However, it only provides an isolated view of each artefact or repository-level statistics. Hence, we are interested in identifying relationships between artefacts in order to have a more complete view of the organization of the MDE projects. To this end, we have built a mega-model of the projects available in the raw dataset. A mega-model is defined as a high-level, "model of models", so that it characterizes the relationships between various models, metamodels, and artifacts within a system [4]. This section describes the process that we have devised to recover a large scale mega-model of MDE artefacts found in GitHub projects.

Connecting the Models: A Global Mega-model of MDE Projects on GitHub

Uploaded to arXiv, ,

Legend upohl/mechatronicuml

Ecore uppaal.ecore

uppaal.odesign

uppaal.ecore

MUML2UPPAAL.qvto

Clocks.qvto MUML2UPPAAL.qvto uppaal.ecore uppaal.odesign

Clocks.qvto uppaal.ecore

Sirius

uppaal.ecore

uppaal.odesign

MUML2UPPAAL.qvto

Clocks.qvto

fraunhofer-iem/uppaal-model uppaal.ecore

DiagnosticTrace.ecore

uppaal.ecore (from mechatronicuml) (from uppaal-model)

Acceleo

QVTo Generates

DiagnosticTrace.xtext (from uppaal-model)

uppaal.odesign (from mechatronicuml)

generator.mtl (from mecha…) uppaal.ecore

DiagnosticTrace.ecore

uppaal.ecore

DiagnosticTrace.ecore MUML2UPPAAL.qvto Clocks.qvto (from mechatronicuml)

DiagnosticTrace.xtext

DiagnosticTrace.xtext

0 Raw dataset

Imports

generator.mtl

generator.mtl

generator.mtl

Xtext

Typed-by

1 Extract local dependencies as artefact graphs

2 Merge nodes with the same file path to produce project graphs

3 Merge nodes whose artefacts are duplicates to produce a global mega-model graph

Figure 4: Mega-model recovery applied to artefacts from § upohl/mechatronicuml and § fraunhofer-iem/uppaal-model.

As a concrete example to guide the explanation, Fig. 4 shows the process in detail for some of the files of the files shown in Fig. 1 (with small modifications to illustrate all cases).

4.1

Recovery of artefact dependencies

In this step we analyze each MDE artefact with the goal of recovering its dependencies. For each artefact we want to obtain a small graph, named artefact graph, in which the artefact is the central node and it has edges pointing to the artefacts it depends on. This is illustrated in Fig. 4 (label 1 ). For instance, MUML2UPPAAL.qvto is the central node of its artefact graph and it has dependencies with files uppaal.ecore and Clocks.qvto. A similar strategy is followed for uppaal.odesign, generate.mtl and DiagnosticTrace.xtext. Technically, to analyze each artefact we define the so called Artefact inspector. An inspector takes an artefact file and generates an artefact graph. Table 2 describes the inspectors that we have implemented and the strategies that are used to recover its dependencies. These strategies are explained in the following. 4.1.1 Dependencies recovery. There are two main types of dependency relationships upon which the other relationships are built: typing relationships and import relationships. Recovering typing relationships. All MDE artefacts refer to one or more metamodels directly or indirectly. In the simplest case the artefact includes an explicit reference to the meta-model (e.g., Xtext has the import statement to refer to a meta-model). Sometimes the meta-model is generated from the artefact (e.g., Xtext provide the generate statement to indicate this fact). Both cases are shown in Fig. 1 (file DiagnosticTrace.xtext). However, some modelling tools use a “dynamic linking” strategy in the sense that meta-models are only known are runtime. For instance, in Epsilon the transformation files do not contain a reference to their meta-model(s). The advantage is that the transformation is not bound to a specific meta-modelling framework and modelling drivers can be used to run the same transformation with different model formats [31]. The downside is

that the actual meta-model needs to be passed as part of the run configuration. Finally, there are tools that that support both explicit meta-model references and dynamic linkage of the metamodel (e.g., ATL and Sirius). Given these scenarios, we identify four possible meta-model recovery strategies: • Extract direct references. This is the most straightforward approach, which is available for “statically typed” artefacts. For each type of tool we have to figure out the way it encodes a reference to its meta-model. For instance, QVTo uses the notion of model type and we need to be able to resolve references to Ecore files relative to the current transformation, but also consider the case of an Ecore file pointed by its URI. • Imitate generation behaviour. For tools which automatically generate the meta-model, we need to emulate this behaviour in the recovery process. In particular, for Xtext we know that the meta-model is automatically placed in the model/generated folder. • Inspect configuration files like Ant’s build.xml or Eclipse launchers to know which meta-model is used at runtime. Many times the repositories contain the configuration files that developers have used to launch their transformations at development time. We analyse patterns typically used by ATL and Epsilon developers in order to identify the meta-models of a transformation. • Compare the footprint of the transformation. For “dynamically typed” artefacts it is possible to extract an approximate meta-model footprint of a transformation [17], by analysing its references to meta-classes. Then, we match such footprints with the Ecore meta-models found in a project and the EMF built-in meta-models. If the 95% of the classes in the footprint can be found in a meta-model, we heuristically select it as the metamodel of the artefact. Recovering import relationships. The recovery of import relationships is simpler since it is typically possible to find a static reference to the imported artefact in the artefact definition. Nevertheless, there are cases in which such references do not point exactly to project artefacts. This is described in more detail in Sect. 4.1.3.

Uploaded to arXiv, ,

4.1.2 Artefact relationship types. As explained, in an artefact graph, a directed edge represent a typing or import dependency between an artefact (the dependent) and another artefact (the dependency). In addition, we attach metadata to each edge according to its role with respect to the referenced artefact. So far we consider the following types of relationships within artefacts in a project: • Typed-by. An artefact is typed by some meta-model. • Imports. An artefact imports another artefact as library or helper. • Generates. An artefact generates another artefact (e.g., a conversion from Emfatic to Ecore) at development time and such a target artefact may appear in the repository explicitly or not. • As-input. An artefact uses instances of the other artefact as input. This is used to identify the input meta-models of a given transformation artefact. • As-output. Similar to as-input. An artefact generates instances of the other artefact as output. Please note that these relationships are not exclusive. For instance, an Xtext file maybe “typed by” an Ecore meta-model and such relationship is also labelled as “generated” if the meta-model is generated by Xtext instead of using an existing one. 4.1.3 Artefact nodes. Each artefact file is mapped to a node in the graph as it is processed when its artefact graph is created. However, as noted before, such artefact may refer to other files (dependencies) which may or may not by present in the repository. Our approach to deal with cases in which a dependency cannot be recovered is to generate a dependency node in the graph even if it does not exist physically in the repository. The rationale is to record such information in the mega-model as well for further analysis (e.g., analyse broken projects). There are four cases: • Exists. The dependency file is found in the repository in its expected path. • Generated. A referred file does not actually exist in the filesystem but it is straightforward to generate it. An example is the Ecore file DiagnosticTrace.ecore generated by DiagnosticTrace.xtext, which may not exist in the repository. • Heuristic. This means that an artefact refers to a file in a way that it is not possible to identify the exact file in the repository or that the reference is ambiguous. This happens when the file is present but our recovery algorithm cannot faithfully recover it. For instance, in an Ant file for configuring an Epsilon transformation a file path may be constructed using runtime information like environment variables (e.g., something like ${projectDir}/MyMetamodel.ecore). Since the environment variable is only available dynamically, we may not know the actual file. However, if we find a file MyMetamodel.ecore in the repository we can heuristically assume that the transformation is actually referring to this file. • Missing. A file is expected but it cannot be found and the heuristic rules cannot be applied. In practice this means that the project is broken (e.g., it may not be possible to make it work because it lacks some artefacts). At the end of this process, each artefact file in the raw dataset has an associated artefact graph encoding its relationships with other artefacts in the repository.

J. S. Cuadrado

Table 2: Artefact injectors currently implemented and metamodel recovery strategies used. Technology

Analysis

Meta-model recovery

Acceleo ATL Ecore Emfatic Emftext Epsilon GMF Henshin OCL QVTo Sirius Xtext

Custom parser AST analysis Load model Custom parser Custom parser AST/Custom parser XPath XPath Custom parser AST analysis XPath AST analysis

Direct Direct, Footprint, Configurations N/A Generated Direct Footprint, Configurations Direct Direct Direct Direct Direct, Footprint Direct, Generated

4.2

Project-specific graphs

The artefact graphs are our intermediate representation to encode dependencies. From this, we are interested in building a larger graph which explicitly reflects the transitive relationships between the recovered artefacts. For instance, in Fig. 4 (label 1 ) we can observe that the recovered graphs for project mechatronic-uml (for the artefacts uppaal.odesign, MUML2UPPAAL.qvto and generator.mtl) actually depend on the same file, the uppaal.ecore meta-model. Hence, it makes sense to combine the different artefact graphs found in a project based on their overlapping artefacts. Our strategy is therefore to merge nodes that refer to the same artefact. In the example, this means merging all nodes that refer to the uppaal.ecore meta-model and rewiring the corresponding edges, obtaining the graph shown in Fig. 4 (label 2 ). A real example of a project graph is shown in Fig. 5. Technically, what we do is to derive an identifier for each artefact using the file path of the artefact relative to the project. This allows us to make sure that merged nodes refer to the same artefact. The case of merging meta-model nodes is a bit more complex because a meta-model can be referenced by its URI or by its file path. When it is referenced by its file path, we apply the regular merging process. If it is referenced by a well known URI2 (e.g., Ecore, UML, etc.) we just use this URI as the node identifier. If the URI is not known, we use an internal index, which maps URIs to meta-model files, to know which file in the project corresponds to such an URI and make the artefact depend on the actual file. Another caveat is merging heuristic nodes. When an edge is created whose target is an node created from an heuristic node two actions are performed: the node is labelled with exists since the file actually exists in the repository and the edge is annotated with heuristic to signify that the recovered relationship may be a false positive. The merging process results in a set of graphs which describe the relationships between the artefacts in each GitHub repository. We call them “project-specific graphs”. These graphs can be used, among other purposes, to explore the configuration of MDE projects.

2We use the list of meta-models URIs built-in in the Eclipse modelling package.

Connecting the Models: A Global Mega-model of MDE Projects on GitHub

4.3

Mega-model graphs

Once we have constructed a graph with the relationships between artefacts in the repositories, in this step we compute a global graph which connects the different repositories. To tackle this, a key observation is that in current MDE technology there is not a package manager (e.g., Maven, NPM, etc.) to facilitate artefact sharing. Instead, developers typically copy-paste artefacts as way of reusing and adapt them. This is shown in Fig. 4, where project uppaal-model publishes a meta-model of the Uppaal tool along with a textual syntax (DiagnosticTrace) to describe the trace of the model checker. Then, project mechatronicuml reuses the meta-model by making a copy and possibly some small adaptations. This means that we cannot use techniques devised to map software artefacts globally [9] since the projects relationships are not explicit. To recover currently implicit project relationships, we adopt the following assumption: if a repository contains a duplicate or nearduplicate artefact from another repository, that artefact would have been shared if a “modeling package manager” were available. To this end, we compute near-duplicates of all of the MDE artefacts by creating specific adaptations of the algorithm proposed by Allamanis [1] to the different artefact types. The algorithm outputs a set of clusters so that each cluster contains the artefacts that are similar. In practice, for textual languages we use the language tokenizer. For XMI-based artefacts we extract the identifiers. We could not apply the approach for Acceleo, Emfatic, Emftext and OCL because we could not access their tokenizers programmatically. For these cases we relied on computing the MD5 sum of the files to identify exact duplicates. In this way, the construction of the global mega-model takes as input the set of project graphs and the duplication clusters and outputs a single graph in which artefact nodes appearing in a duplication cluster (i.e., this means that the artefact has duplicates in other repositories) are replaced by a single node representing the cluster and the edges are redirected. These nodes are called artefact groups. In this way, our mega-model makes reuse relationships between projects explicit by representing common artefacts with a single node. In Fig. 4(label 3 ) the element that is duplicated in both projects is uppaal.ecore. In the mega-model, both nodes are merged into a single node (the artefact group) and the edges are rewired to point to the merged node. Fig. 6 shows the mega-model of our dataset, in which it is possible to observe several large hubs (Ecore, UML) and many other connected components. From this mega-model graph it is possible to derive other useful graphs or pieces of information. In particular, in this work we also compute the so called inter-project graph. This graph is intended to represent dependencies between projects, so that a project A depends on another project B if it has an artefact that is defined in project B. We take advantage of the artefact groups stored in the mega-model to derive this graph. A simple approach is to consider that a project is related to another if it contains a duplicated element from such a project. This approach assumes that in a artefact group we do not know which one is the original, and therefore generates an edge among all projects which contain duplicates. To make the graph construction more precise, we take advantage of the temporal information recorded in the raw dataset (attribute createdAt in Fig. 3).

Uploaded to arXiv, ,

We apply the heuristic that, in an artefact group, the original artefact is the older one. In this way, a project depends only on the project that contains the original artefact. This graph is useful to identify related projects. For instance, if we are interested in understanding which projects perform formal analysis using Uppaal, we can find a promising seed project by looking up the uppaal.ecore or similar artefacts. Then, from a project defining such artefact (i.e., uppaal-model) we can discover projects like utwente-fmt/attop which verifies attack trees, sillymoi/remes-ide to model embededded software, fraunhofer-iem/mechatronicuml for designing and analysing mechatronic systems, etc.

5

Dataset availability and tooling

The tangible product of the process described below consist of two datasets: the raw dataset and the mega-model graph. Both datasets are important contributions to improve our knowledge about how MDE has fared in public repositories. The complete dataset, which we name ModelGraph and the source code to reproduce the complete process is available at https://models-lab.inf. um.es/files/modelgraph-dataset/. We also provide a web tool to facilitate the exploration of the dataset at https://models-lab.inf.um. es/modelgraph-ui/.

5.1

Datasets and APIs

The datasets consist of two SQLite databases plus a Java API to reconstruct the different graphs and access the artefact and repository information. The raw database has the schema shown in Fig. 3. We store the mega-model in a relational database for convenience. In practice, we load it as a JGraphT3 graph which allows users to navigate the graph (e.g., obtain outgoing edges of a node) and apply algorithms very easily (e.g., find connected components).

5.2

Exploring tool

To facilitate the exploration of the provided data we have built an interactive tool. The tool was initially intended to allow us to inspect and debug our results, but we finally decided to polish it and make it available as part of the contribution. It can be used both locally or remotely at https://models-lab.inf.um.es/modelgraph-ui/. Fig. 5 shows the project of § utwente-fmt/attop. The tool provides the following features: It displays statistics about the artefacts, explore projects graphs (with facilities search for projects), explore the inter-project graph and the exploration of the global mega-model. It also provides facilities for filtering nodes and edges by type.

6

Discussion

In this section we assess the dataset from different perspectives. First, we discuss its limitations and potential shortcomings. Then, we present a discussion regarding the contents of the dataset. Finally, we discuss potential usages.

6.1

Limitations and threats

To use the dataset effectively it is important to take into account its limitations and how they may affect (or not) its use. We have classified these aspects in six categories which are described next. 3 https://jgrapht.org/

Uploaded to arXiv, ,

J. S. Cuadrado

approach to ensure the correctness of the implementation has been to sample a number of projects after each major implementation change and manually check the correctness of the graph, fixing bugs as needed.

Figure 5: Screenshot of the tool, showing the project graph of § utwente-fmt/attop.

Projects vs. repositories. We made the assumption that each repository represents a project, but this is not necessarily true. A concrete example of this is § fraunhofer-iem/mechatronicuml which was migrated from a mono-repository to a multi-repository. This poses a limitation on our method since it does not handle well references across repositories in the same project. In the graph, this is reflected as broken links (i.e., an edge pointing to an expected artefact which is not present in the repository). Nevertheless, such particular type of broken links could be fixed in a post-processing phase applying heuristics (e.g., if there is a file path ../../siblingrepository/metamodel.ecore it is likely a cross-repository reference). Duplicate finding. The deduplication algorithm depends on parameters which are set heuristically (see [1]). Also, we have applied adaptations of the algorithm for XMI serialized artefacts (e.g., Ecore, Henshin, etc.) following [21]. However, more studies are needed about the best way to find duplicates in modelling artefacts. In particular, we have noticed that the algorithm sometimes do not fully capture synthetic duplicates, like the ones done for mutation experiments.

Figure 6: Megamodel visualized with our exploration tool.

Completeness. Regarding the completeness of the dataset, as we have explained, we may have missed some repositories which do contain MDE artefacts, in particular those created between 2020 and 2025 which have not had any activity and are not currently indexed by the GitHub search API. We have tried to alleviate this by also cloning repositories from the MAR dataset. In total, the MAR dataset added about 1,000 repositories which are not available through the GitHub API. Focus on Eclipse technologies. Another issue related to completeness is that the dataset is currently focused on modelling technologies around the EMF ecosystem. We have tried to cover a wide range of technologies in the ecosystem, in particular those with more usage. In future versions we could include other EMF-based technologies not covered so far like Kermeta, Viatra, etc. On the other hand, there are other technical spaces worth considering like MPS, Spoofax or Monticore. In future work we plan to replicate our approach for these spaces and compare the resulting mega-models. Correctness. We have manually implemented inspectors for many types of MDE artefacts. A potential threat is that we might be missing some features of the languages or having made some implementation mistake. Given the sheer amount of processed artefacts, our

Temporal dimension. The mega-model is computed on a specific snapshot of the cloned repositories (in particular, 2026/03/04). It is technically possible to have historical views of the mega-model, but it requires checking out older branchs of each repository (which is fast) and then running the mega-model computation process again (which is slower). To address this we would like to optimize the pipeline to support the efficient computation of past mega-models in order to study the technology evolution. In any case, the megamodel do support some time-dependent analysis since each artefact is annotated with the creation and last update timestamps. This already allows interesting applications like finding copy relationships between artefacts (that we use to compute the inter-project graph) or analysing the usage evolution of artefact types.

6.2

Assessment

In the following we realize an assessment of the dataset. For space reasons, the quantitative part is limited to some aggregated metrics (Tables 1 and 3). Nevertheless, the online tool and the dataset package provide additional metrics. Artefacts. The final mega-model consists of 7,436 repositories and 327,762 MDE artefacts of 12 types. Table 1 shows the distribution. Most of the artefacts are Ecore meta-models. There are also a large number of Henshin files but we have found that most of them are experimental data and mutants (90% of the Henshin artefacts belong to just 10 research projects). To understand better the how artefacts are distributed, the fourth column of Table 1 (Project ocurrences) shows the percentage of projects with at least one artefact of the given type. In other words, it reflects the spread of each type of artefact in practice, regardless of its number of files. As expected, Ecore is used in the majority of projects since, in MDE, all artefacts revolve around a meta-model. Emftext and Henshin seems to be marginally used. Emftext do not receive updates since 7 years ago

Connecting the Models: A Global Mega-model of MDE Projects on GitHub

while Henshin seems to be mostly used in research projects. A notable case is Xtext since it is used in about 40% of the projects. Duplication. To analyse duplication, we have counted the number of artefacts that are unique (see fifth column of Table 1) in the sense that a) no duplicate is found by our algorithm or b) if several artefacts are deemed as duplicated we count them as only one. Most of the Ecore artefacts are duplicates. Some of the largest duplication groups corresponde to well known meta-models like ATL.ecore, p2.ecore (Eclipse updates plataform), XML.ecore, etc. which are copied from project to project for different purposes like testing, building datasets and especially creating new transformations or providing a concrete syntax (see the running example, uppaal.odesign provides a concrete syntax to the copied uppaal.ecore). Except for Henshin, the amount of duplication in the rest of the artefacts is less pronounced. In ATL, a typical source of duplication is copypaste-modify of transformations from the ATL Zoo. The amount of duplication Epsilon artefacts is smaller than similar artefacts like ATL. We hypothesize that it might be because they are used for building actual modelling environments and less for doing research experiments or prototypes (which tend to reuse past data). Therefore, the fact we have have found a large amount of duplication all types of artefacts suggests that build management systems (akin to Maven) are in great need in the MDE community [27]. Mega-model nodes and relationships. Table 3 summarizes the recovered data at the mega-model level. There are more than 70,000 nodes. An important aspect to consider is that the mega-model aggregates duplicate elements in a single node and therefore the number of nodes is smaller than the number of processed artefacts. About 37% of the nodes are isolated and no dependencies were derived from them. The number of edges is about 77,000, with an average degree of 1,73 edges per node (excluding isolated nodes). There are several causes for node isolation. In particular, most of the isolated nodes are Ecore meta-models (20,565 nodes). When an Ecore meta-model appears as an isolated node the causes can be: (1) the references to the meta-model are found in a file whose technology we do not support, 2) there is a bug in an inspector, 3) the meta-model is referenced in Java code (which we do not consider) or 4) it is really an isolated model (typically this happens in repositories which belong to experiments or datasets). We have found cases of (1) like § NCIP/lexevs which applies XSLT transformations to XMI files directly. There are also several cases of 3) of increasing complexity: from simple transformation launchers that configure a meta-model via its URI or file path and could be analysed heuristically building a dedicated static analyser, to projects that load meta-models reflectively and therefore cannot be handled. It is not possible to determine exactly the cause for a node to be isolated (whether it is a false negative or not) without a complete manual inspection, but we manually checked a large number of cases and most of them are datasets or meta-models referenced from Java files. We have also computed the number of connected components in the graph (see #components). Each component indicates a cluster of related artefacts. There is a very large component (29,239 nodes), a few more with 100 to 200 elements, and then many small components. Project relationships. Table 3 shows some statistics about the relationships identified using the inter-project graph. The number

Uploaded to arXiv, ,

Table 3: Graph statistics at the mega-model and project levels. Mega-model metrics #nodes 70,645 #isolated 26,304 (37%) #edges 77,933 avg. degree 1.76 #components 4,159

Project metrics #projects 7,436 #isolated 4,478 (60%) #edges 5,179 avg. degree 1.75 #components 113

of isolated projects is high (60%) which means that many projects are build from scratch. Given the amount of duplication at the artefact level, this means that project that reuse artefacts, tend to copy many of them. The average node degree is 1.74 which is in line with artefact connectivity. There are very few connected components at the inter-project level, partly because there is a very large component with 2,681 projects. In the future, we would like to have a more precise analysis trying to identify main hubs of the network. Building process. The full process spans several days, primarily bounded by the time-intensive task of crawling and recovering artifact metadata from GitHub. Cloning the required repositories adds several hours and generates approximately 1.3 TB of data. Furthermore, identifying specific MDE artifacts involves traversing Git histories to locate both the oldest and newest commits (about 5 hours), while the final generation of the global mega-model and deduplication algorithms takes about 3 hours. To improve efficiency we want to explore newer GitHub API techniques [2] and optimise some parts of the implementation.

6.3

Potential usages of the dataset

In this section we discuss the usefulness of our work in terms of how the community could profit from it. At the repository level the raw dataset could be used to answer questions about the maturity and health of the MDE projects. This includes questions like: What is the engineering maturity of MDE projects?, Are domain tools more or less mature than meta-tools? or What is the survival rate of MDE projects?. To answer these questions techniques to compute engineered-project scoring (CI, contributors, commit history, issues, license) needs to be adapted to MDE [23], then classify projects into meta-tools and domain-tools (e.g., using ML techniques and datasets like ModelSet [19]) and study metrics like commit distribution. Another line of work is to study technology combinations in depth, answering questions like Which MDE technologies are most commonly co-used within a single project?, Do projects combine several technologies? or How preferences about MDE technologies have changed over time?. At the mega-model level the dataset could be used to analyse several aspects of how MDE is used in practice which are not well known yet. For instance, about network structures it would be interesting to answer: Which are the central hubs? and What type of connected components can be identified?. Also, it is possible to analyse structural patterns (motifs) like Xtext → Metamodel → ATL in order to discover what are the most frequent structural motifs in the global mega-model. Another important topic in MDE is reuse. It would be interesting to answer questions like For which application

Uploaded to arXiv, ,

domains are copy-paste more prevalent? and devise methods to identify duplication causes: Do duplicates follow a “provenance” tree (one original, many copies) or a web (multiple independent derivations)? and Is there evidence of unintentional copy-paste vs. intentional forking? The dataset can also be used to improve empirical evaluations of MDE tools. For instance, in [6] a static analyser is used to detect errors in 100 model ATL transformations curated in a repository. The study required to manually annotate each transformation with its meta-model. Now, this type of study could now be done at a larger scale (or applied to other technologies like Epsilon) because our system automatically perform this recovery and seamlessly provides a dataset of thousands of transformations. Another line of work is to train or fine-tune AI models specific of MDE. The fact that the artefacts are already deduplicated would facilitate this task. In addition, the recorded relationships can also be useful to enrich the training data. In this manuscript, for space reasons, we cannot further evaluate the contents of the mega-model or explore some of the research questions. Nevertheless, we believe our contribution can be an important resource for the modelling community either to address the mentioned applications or others that we have not foreseen.

7

Related work

Several works have mined software repositories to perform empirical studies and understand the dynamics of software projects and artefacts. For instance, Decan et al. [10] studied 830K packages from several package managers (e.g., Cargo, CPAN, CRAN or npm) to understand the evolution of dependencies among them. In the Java ecosystem is common to analyse how projects use Maven dependencies. For instance, in [26] Maven packages have been analysed taking into account their popularity using information from GitHub, while in [28] the focus is on the growth of unused dependencies as projects evolves. These types of empirical analysis have not been possible so far in the MDE ecosystem. Our mega-model can play the role of the dependency information available in online package managers and enable these types of analysis. In the modelling field some works have analysed open source projects to study the usage of specific types of MDE artefacts. At the model level, UML and BPMN has been widely studied. In [14] around 8,000 BPMN models (after removing exact duplicates) were mined from GitHub and analysed to find violations of syntax and semantics. Similarly, 20,000 BPMN models are mined and analysed in [5]. The latest effort to analyse BPMN [25] have analysed about 5,000 repositories and 25,000 models, finding that 90% are clones. Regarding UML, a large dataset of UML models was made available in [13], although the dataset is not actually analysed to check the validity of the artefacts. More recently, in [24] analyse the usage of UML models in GitHub. In our work, we have not included model artefacts, but we can observe large hubs around the UML and BPMN meta-models which highlights the interest of these type of models. Other works have focused on the meta-level. In [30] an empirical investigation about Xtext usage in GitHub is performed, which comprised manual classification of the repositories, locating DSL programs within the repositories and identifying co-evolution issues across versions. In [3], 32,832 unique Ecore meta-models

J. S. Cuadrado

were crawled from GitHub, GHTorrent and the Software Heritage Dataset. The authors performed a deduplication phase but only by computing hashes. Then, an analysis of how the Ecore metametamodel is used is performed (i.e., how the Ecore elements are used to create meta-models). It is also worth noting that [3] shows that the majority of public EMF meta-models reside in GitHub. A recent work have studied the causes of duplication for Ecore metamodels in public projects [7]. Our dataset would enable replicating this study and extending it to a wider range of artefact types. In [22] a large corpus of OCL expressions is contributed and analysed. The MAR search engine crawled about 500,000 different types of models, including Ecore and Xtext files [20], however it does not identify relationships between the artefacts. We have used its list of crawled repositories to enhance our dataset. In terms of the method to recover artefact depedencies, our artefact graph recovery mechanism is partially inspired by [11], but we add new support for broken dependencies through heuristics and cover many more file types. Moreover, the scope of this work is broader since we build a global mega-model and contributes an actual dataset. Also, our artefact graphs are an scalable way to recover information and even make the process parallelizable. In the same line, AMINO [12] is a tool to discover relationships between modelling artefacts and to compute quality metrics. AMINO is not intended to be applied at scale and it only supports a small number of artefact types, but the proposed quality metrics could be applied to complement our dataset. Tairas and Cabot [29] presents a method to analyse DSL usage, including clone detection and analysis. These techniques could be applied to our dataset to derive new knowledge about MDE languages usage. There are few works that have analysed complete projects. The most notable exception is the work by Cánovas Izquierdo et al. [16] which analysed the maturity level of modelling projects hosted by Eclipse. They show that modeling projects are slightly less mature than non-modelling projects. A recent work have analysed the historical trend of model transformation language usage [8]. Our work can be used to complement such analysis and shed more light on the causes of the decline of model transformation technology.

8

Conclusion

In this paper we have presented a method to construct a global mega-model from public MDE artefacts. We have considered 12 different artefact types mined from GitHub, encompassing metamodels, transformations, concrete syntax and code generators. The mega-model represents relationships between artefacts at different levels: individual files, project and global levels. To the best of our knowlege, this is the largest dataset of MDE artefacts and the only one describing artefact relationships. As future work we plan to continue enhancing the dataset by improving the artefact inspectors (e.g., recover dependencies from Java files) and also including instance level artefacts by crawling models like UML and BPMN models. We also would like to address the temporal dimension by providing a sequence of mega-models captured at fixed timestamps. Regarding the use of the dataset, we plan to start addressing some of the research questions, in particular those related to network analysis to identify MDE usage patterns. We also want to experiment training AI models with the dataset.

Connecting the Models: A Global Mega-model of MDE Projects on GitHub

References [1] Miltiadis Allamanis. 2019. The adverse effects of code duplication in machine learning models of code. In Proceedings of the 2019 ACM SIGPLAN international symposium on new ideas, new paradigms, and reflections on programming and software. 143–153. [2] Maxime André, Marco Raglianti, Souhaila Serbout, Anthony Cleve, and Michele Lanza. 2026. PoolinGH: Fast, Efficient, and Robust GitHub Repository Mining. In Proceedings of the 23rd International Mining Software Repositories Conference (MSR 2026): Data and Tool Showcase Track. ACM Press. [3] Önder Babur, Eleni Constantinou, and Alexander Serebrenik. 2024. Language usage analysis for EMF metamodels on GitHub. Empirical Software Engineering 29, 1 (2024), 23. [4] Jean Bézivin, Frédéric Jouault, and Patrick Valduriez. 2004. On the need for megamodels. In proceedings of the OOPSLA/GPCE: best practices for model-driven software development workshop, 19th Annual ACM conference on object-oriented programming, systems, languages, and applications. 1–9. [5] Ivan Compagnucci, Flavio Corradini, Fabrizio Fornari, and Barbara Re. 2021. Trends on the usage of BPMN 2.0 from publicly available repositories. In International Conference on Business Informatics Research. Springer, 84–99. [6] Jesús Sánchez Cuadrado, Esther Guerra, and Juan de Lara. 2018. Anatlyzer: An advanced ide for atl model transformations. In Proceedings of the 40th international conference on software engineering: Companion proceeedings. 85–88. [7] Alfonso de la Vega and José Antonio Hernández López. 2025. Analysis of EMF meta-model duplication in open-source repositories. ACM Transactions on Software Engineering and Methodology (2025). [8] Juan de Lara, Esther Guerra, and Jesús Sánchez Cuadrado. 2026. Have model transformation languages failed? On the rise, fall and revival of model transformation languages. Software and Systems Modeling (2026), 1–15. [9] Alexandre Decan and Tom Mens. 2021. What Do Package Dependencies Tell Us About Semantic Versioning? IEEE Trans. Software Eng. 47, 6 (2021), 1226–1240. [10] Alexandre Decan, Tom Mens, and Philippe Grosjean. 2019. An empirical comparison of dependency network evolution in seven software packaging ecosystems. Empir. Softw. Eng. 24, 1 (2019), 381–416. [11] Juri Di Rocco, Davide Di Ruscio, Johannes Härtel, Ludovico Iovino, Ralf Lämmel, and Alfonso Pierantonio. 2020. Understanding MDE projects: megamodels to the rescue for architecture recovery. Software and Systems Modeling 19 (2020), 401–423. [12] Davide Di Ruscio, Ludovico Iovino, and Alfonso Pierantonio. 2024. AMINO: A quality assessment framework for modeling ecosystems. Journal of Software: Evolution and Process 36, 5 (2024), e2603. [13] Regina Hebig, Truong Ho Quang, Michel RV Chaudron, Gregorio Robles, and Miguel Angel Fernandez. 2016. The quest for open source projects that use UML: mining GitHub. In Proceedings of the ACM/IEEE 19th international conference on model driven engineering languages and systems. 173–183. [14] Thomas S Heinze, Viktor Stefanko, and Wolfram Amme. 2020. Mining BPMN Processes on GitHub for tool validation and development. In International Conference on Business Process Modeling, Development and Support. Springer, 193–208. [15] John Hutchinson, Jon Whittle, Mark Rouncefield, and Steinar Kristoffersen. 2011. Empirical assessment of MDE in industry. In Proceedings of the 33rd international conference on software engineering. 471–480. [16] Javier Luis Cánovas Izquierdo, Valerio Cosentino, and Jordi Cabot. 2017. An empirical study on the maturity of the eclipse modeling ecosystem. In 2017 ACM/IEEE 20th International Conference on Model Driven Engineering Languages and Systems (MODELS). IEEE, 292–302. [17] Juan De Lara, Esther Guerra, Davide Di Ruscio, Juri Di Rocco, Jesús Sánchez Cuadrado, Ludovico Iovino, and Alfonso Pierantonio. 2019. Automated reuse of model transformations through typing requirements models. ACM Transactions on Software Engineering and Methodology (TOSEM) 28, 4 (2019), 1–62. [18] Grischa Liebel, Nadja Marko, Matthias Tichy, Andrea Leitner, and Jörgen Hansson. 2018. Model-based engineering in the embedded systems domain: an industrial survey on the state-of-practice. Software & Systems Modeling 17, 1 (2018), 91–113. [19] José Antonio Hernández López, Javier Luis Canovas Izquierdo, and Jesús Sánchez Cuadrado. 2022. ModelSet: a dataset for machine learning in model-driven engineering. Software and Systems Modeling 21, 3 (2022), 967–986. [20] José Antonio Hernández López and Jesús Sánchez Cuadrado. 2022. An efficient and scalable search engine for models. Software and Systems Modeling 21, 5 (2022), 1715–1737. [21] José Antonio Hernández López, Riccardo Rubei, Jesús Sánchez Cuadrado, and Davide Di Ruscio. 2022. Machine learning methods for model classification: a comparative study. In Proceedings of the 25th International Conference on Model Driven Engineering Languages and Systems. 165–175. [22] Josh GM Mengerink, Jeroen Noten, and Alexander Serebrenik. 2019. Empowering OCL research: a large-scale corpus of open-source data from GitHub. Empirical Software Engineering 24, 3 (2019), 1574–1609. [23] Nuthan Munaiah, Steven Kroh, Craig Cabrey, and Meiyappan Nagappan. 2017. Curating github for engineered software projects. Empirical Software Engineering 22, 6 (2017), 3219–3253.

Uploaded to arXiv, ,

[24] Joseph Romeo, Marco Raglianti, Csaba Nagy, and Michele Lanza. 2025. UML is back. Or is it? Investigating the past, present, and future of UML in open source software. In 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE, 2342–2354. [25] Mahdi Saeedi Nikoo, Sangeeth Kochanthara, Önder Babur, and Mark van den Brand. 2025. An empirical study of business process models and model clones on GitHub. Empirical Software Engineering 30, 2 (2025), 48. [26] Sadman Jashim Sakib, Muhammad Asaduzzaman, Curtis Bright, and Cole Morgan. 2025. Understanding the popularity of packages in Maven ecosystem. In 2025 IEEE/ACM 22nd International Conference on Mining Software Repositories (MSR). IEEE, 364–368. [27] Beatriz Sánchez, Dimitris Kolovos, and Richard Paige. 2020. To build, or not to build: ModelFlow, a build solution for MDE projects. In Proceedings of the 23rd ACM/IEEE International Conference on Model Driven Engineering Languages and Systems. 1–11. [28] Nabhan Suwanachote, Yagut Shakizada, Yutaro Kashiwa, Bin Lin, and Hajimu Iida. 2025. On the evolution of unused dependencies in Java project releases: an empirical study. In 2025 IEEE/ACM 22nd International Conference on Mining Software Repositories (MSR). IEEE, 324–328. [29] Robert Tairas and Jordi Cabot. 2015. Corpus-based analysis of domain-specific languages. Software & Systems Modeling 14, 2 (2015), 889–904. [30] Weixing Zhang, Daniel Strüber, and Regina Hebig. 2026. Development and evolution of Xtext-based DSLs on GitHub: an empirical investigation. Empirical Software Engineering 31, 3 (2026), 48. [31] Athanasios Zolotas, Horacio Hoyos Rodriguez, Stuart Hutchesson, Beatriz Sanchez Pina, Alan Grigg, Mole Li, Dimitrios S Kolovos, and Richard F Paige. 2020. Bridging proprietary modelling and open-source model management tools: the case of PTC Integrity Modeller and Epsilon. Software and Systems Modeling 19, 1 (2020), 17–38.

Received March 2026