ModelioOpenSource/Modelio: a desktop modeling environment for UML, BPMN and ArchiMate

UML, BPMN and ArchiMate in one environment

Modelio is a modeling solution offering a wide range of functionality based on the main standards of enterprise architecture, software development and systems engineering, and it is written for developers, analysts and software and systems architects.

The standards list is where the scope becomes clear. UML2 is the general purpose modeling language from the OMG used in object-oriented software engineering. BPMN2 is the standard for business process modeling, providing a graphical notation for the specification of business processes. ArchiMate is an open and independent enterprise architecture modeling language to support the description, analysis and visualization of architecture within and across business domains. XMI is the OMG standard for exchanging metadata information via XML, MDA is an OMG standard that implements and uses model extensions in the development of software systems, and TOGAF is an enterprise architecture framework providing a complete approach to enterprise information architecture design, planning, implementation and governance.

That is a wide surface, and the interesting structural decision is how the pieces relate. BPMN support is integrated into Modelio rather than bolted on, and those BPMN models can be linked to other standards the tool supports, for example UML, so as to integrate business processes into a larger context such as an enterprise architecture. A process model and the architecture that hosts it live in the same model, which is the whole argument for a single environment rather than a suite of tools with export and import between them.

The tool also provides model assistance and consistency-checking features, which is the part that makes a model worth keeping. A diagram that is a picture ages badly, and a model that is checked is a document that can be part of a build.

The visual query tool is the headline of 6.2

Modelio 6.2 introduces a series of major improvements focused on usability and model exploration, and the flagship addition is a brand new visual query tool.

Its purpose is stated precisely: it allows all users, technical or not, to build powerful, targeted searches across their models without writing any code. Queries can be filtered by element type, name, properties and relationships, which the release note says makes it significantly easier to navigate large and complex architectures.

The phrase without writing any code is the significant part. In a large ArchiMate or UML model, finding every element of a type with a particular property, or every relationship pointing at a given element, is the kind of question that either needs a query language or a lot of clicking. Shipping the search as a visual tool rather than as a query DSL is a statement about the audience, and about how many enterprise architects actually use these models.

The second headline is automatic diagram layout, which intelligently reorganizes graphical elements using algorithms such as tree layout and overlap removal. The important detail is that it is accessible both interactively and through the module API for automation scenarios, so a build pipeline can re-lay out a diagram the same way a user would.

That pairing, a better search and a layout you can script, is what a tool for large models needs, and it is a coherent theme for a release.

ArchiMate elements can change type without moving on the canvas

The ArchiMate support has been substantially strengthened in 6.2, and one of those changes is more interesting than it sounds.

Elements can now be transformed from one type to another while preserving their diagram positions. In practice, that means a node drawn as one kind of ArchiMate element can be changed into another kind, and it stays exactly where it was on the diagram rather than jumping to a new coordinate when the graphical representation changes.

That is a modelling tool fix for a modelling tool problem. ArchiMate has a large type hierarchy, and a model that evolves usually reclassifies things, a Business Process that turns out to be an Application Component, for example. Without this, each reclassification disturbs the diagram, and a diagram that gets disturbed on every refactoring stops being a usable document.

The other ArchiMate changes are more conventional but still relevant. Graphical representations have been updated for better standard compliance, and duplicate links are now correctly displayed on import, which is a bug that would have been invisible until you imported a model that contained them.

The links editor and diagram tooling also received targeted refinements, including case-insensitive element search, link name display in unmask dialogs and a more visible graphical properties panel. The 6.0, 6.1 and 6.2 patch releases address stability in Teamwork collaboration, BPMN lane management, HTML notes editing, XMI import and export, and general diagram rendering, which is a useful signal about where the friction was.

The Java Designer module, and the other five

The main features list has seven items, and the Java one is the most concrete.

The Java code generator uses an RCP and Eclipse style project file structure, and supports Java code generation and reverse, Javadoc generation and Java automation. So it is not only a diagram to code tool, it also goes the other way, reading existing code back into a model, and it produces Javadoc, which in practice means the model is close enough to the code to be a source for the documentation as well.

The XMI import and export feature enables you to exchange UML2 models between different tools, which is the interoperability escape hatch. The HTML Publisher module publishes your models in HTML format, which turns a model into something a wider audience can read without a Modelio licence.

The extension system is the one that determines the tool's longevity. Modelio can be extended for any language, methodology or modeling technique just by adding modules to your configuration, and you can either use existing modules or develop your own. That is a plugin architecture with the modelling standards as the payload, and it is the reason the tool can claim to be relevant to a methodology it was not written for.

And there is integrated support for the Jython scripting language, for online requests, small scripts and macro definition, which means the repetitive parts of model editing can be scripted in Python rather than clicked.

Sample projects instead of an empty canvas

The repository ships a set of projects illustrating the main frameworks supported, and they are more useful than a screenshot gallery because they can be opened and inspected.

To access them you download the desired project archive and use the Import project from archive function in Modelio, at File > Import Project.

The four examples cover different corners of the tool. The ArchiMate example is a Discount Travel project modelling the enterprise architecture of a travel agency to manage its reservation system. The JavaDesigner example is a simple HTML browser based on a Swing JEditorPane component, which is a small but complete example of the code generation side. The SysML example is The plant, from the Systems and Automation Department at the Federal University of Santa Catarina, an experimental unit of industrial automation used to demonstrate several control strategies with the same equipment and supervision tools. And the UML example is Shopping Cart, a model of an online shopping cart system covering the analysis of the business context and processes and the design and deployment of a possible implementation.

Each of those demonstrates a different way in: architecture, code, systems engineering and software design. For a tool whose hardest problem is being convincing, opening a finished model is the fastest way to judge it.

Building the tool from source is a documented exercise too, with a Building Modelio from Source guide in the wiki, and the repository layout shows a Maven build with a `pom.xml`, a `modelio/` directory for the application, `modelio-lib/` for the library, a `dev-platform/` for the development platform, `products/` and `features/`.

Where this is the wrong tool

The first wrong case is a code first team. Modelio is a modeling environment, and the Java code generator is one module among several. If your work is writing code, this is a heavier way to arrive at the same thing than an editor and a compiler, and the reverse engineering direction only makes sense if you already have a model worth keeping.

The second is a team that only needs one standard and a small model. Supporting six standards means a large application, and for a single BPMN diagram the overhead of a general environment is not repaid. A lighter diagram tool or a text based notation in a repository is often the better answer for a small artefact.

The third is an environment where a desktop application does not fit. Modelio is a Java application with a project format, an import function and modules, and it assumes a person sitting at a workstation. There is nothing here about a service that holds models for many people at once.

The fourth is a requirement for a specific collaboration model. The release notes mention Teamwork collaboration in the context of bug fixes, which tells you there is a collaboration story, but the documentation in the repository is thin on how it works and on what it costs at scale, so a team that needs a reviewable model workflow should read the wiki before committing.

On the state of the project, the release history is unusual and worth reading carefully. The tags are v5.3.1 from 2023-03-31 and v5.4.1 from 2023-12-07, then a jump to v6.2.0 on 2026-08-26, with the last push on the same day and the repository not archived. The gap between the 5.x tags and 6.2 is real, and the wiki holds the 6.2 release note and the documentation that goes with it. The licence is GPL-3.0, and for an organisation standardising a modeling tool that is a fact to plan for rather than a surprise.

Editorial conclusion

Adopt Modelio if your work is producing models rather than shipping an application, since it brings UML, BPMN and ArchiMate into one environment with consistency checking, XMI exchange and a scripting layer, and its sample projects give you a starting point instead of an empty canvas. Do not adopt it as a general purpose IDE or a code first workflow, because the tool's value is in the models and the code generation is one module among several. Verify first which standards you actually need, because the release notes for 6.2 concentrate on ArchiMate and on diagram tooling, and check your own working pattern against the release history, since the previous tags are from 2023 and the project went quiet before returning with 6.2.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. ModelioOpenSource/Modelio on GitHub
3. Project website
4. README
5. Releases