Sirius Web: What’s up, Doc?

This talk features an update on Sirius Web, an open-source project by the Eclipse Foundation dedicated to creating domain-specific graphical modeling tools. Melanie Bats, the CTO at Obeo, and architect Stephen Megudo discuss enhancements to the project's usability, performance, and collaborative features. Sirius Web aims to simplify the user experience by enabling access through web browsers without complex installations. The architecture is built on Java with a Spring Boot backend and a React frontend, allowing for a declarative interface design. Recent updates include improved diagram editing, enhanced shared context features for collaboration, and significant performance improvements, all aimed at supporting larger models and integration into modern development environments. The evolution of Sirius Web reflects a strong contributor base and a commitment to continuous improvement, making it suitable for enterprise applications.

Hello. Hi. Okay, let's start. So, hello everyone. Uh today Stephen and I are going to give you an update on Sirius Web and share what has been happening recently in the project. So, I'm Melanie Bats, CTO at Obeo, and with me is Stephen Megudo who is the architect behind Sirius Web. Hi everyone. So, I'm working on the architecture and implementation of Sirius Web, and today I'll walk

you through many of the improvements that have happened recently. let's start with the bigger picture with a quick reminder of what Sirius is. Sirius is an Eclipse Foundation open-source project dedicated to building domain-specific graphical modeling tools. It has been in your run for more than 15 years now, so it has proved itself in a complex engineering environment. Um the core idea is very simple. Sirius lets tool

builders focus on their domain concepts and rules instead of spending time building low-level graphical infrastructure like before. In other words, uh you bring your model and your rules, and Sirius helps provide the graphical workbench around it. And this naturally led us to the next step, bringing this approach to the web. So, with Sirius Web, the goal is to make modeling tools easier to access, easier to deploy,

and easier to integrate into modern environments. Um for end users, this means no localization and no complex setup. Everything is accessible directly through the browser. And technically, this also makes integration much easier with today's ecosystems, whether we talk about ALM, PLM, CI/CD, or authentication services. It also creates a better foundation for scalability and for more collaborative usage patterns. So, to understand how Sirius Web supports all of

this, let's look briefly at its architecture. So, Sirius Web relies on a Java and Spring Boot back end with a React front end. The platform uses a declarative approach with our view DSL, so tool builders don't have to code every part of the user interface manually. It also remains compatible with the Eclipse Modeling Framework for data structure, which is important for the broader Eclipse Modeling ecosystem. And

from a product perspective, this open foundation is also key. It gives transparency, extensibility, and a solid base for industrial adoption. So, always that in mind, let's look at what has changed recently, because a lot has happened since late 2024, last time we did this kind of uh presentation. So, Sirius Web has been evolving very quickly over the past months. The project is very active with a strong

contributor base, frequent pre-releases, one release each eight weeks, and a steady flow of improvements across the platform's entire platform. So, this strong rhythm reflects the growing adoption of Sirius Web across several modeling tools and several use cases. And this activity has translated into many concrete improvements. Since the end of 2024, Sirius Web has evolved very quickly in various directions. We will introduce continuous improvement on usability, diagram

editing, performance, new representations, and also work on the extensibility of the platform. So, first we chose to start to present the end user the end user features because many of the recent improvements are really immediately visible in day-to-day usage. And a lot of that progress comes from work on the workbench itself. I mean, navigation, feedback, responsiveness, and the overall usability. So, these changes are not always spectacular

on their own, but together they make the platform much smoother and much more comfortable to use. And that matters a lot for your users of your modeling tools because adoption is not only about adding features, adding features. It's also about whether the tool feels simple, fluid, and almost reliable everyday yeah, day-to-day work. So, we improve the action in the product contextual menu used to generate shareable URL

for the current workbench state. So, this shared state can now include things like the current selections, the views that are open in the left and right panels. So, instead of sharing only a project, users can now share the entire working context, which makes collaboration much easier. End users can now display multiple workbench views simultaneously on both the left and right panels of the workbench. So, it gives

user more control over how they structure their workspace and access information. This helps create a more modular environment where users can focus on the views that matters for recurring tasks. Another area where SiriusWeb has progressed a lot is diagram editing. This is really central because for many users the diagram is still the main entry point to interact to to interact with the model. And over the last

releases we worked a lot on making diagram editing smoother, more readable and more comfortable in day-to-day usage. So and this is really about maturity for SiriusWeb. Not just adding features but making the editor feel more natural and more robust. The goal here was to make diagram editing more fluid and more predictable. And that includes better feedback during move and resize operation, more intuitive selection handling, improves for

example snap-to-grid behavior, um more consistency across browser if you're using Firefox or Chrome. And it we work also on reducing the latency in the front end. So the result is simple. Just for you editing feels smoother and more reliable but yeah, that's it. But it's a lot. So a good example of that is the work we did on the palette. So the palette is one of the

first thing users interact with when they create or modify elements in the diagram. So reworking it has a strong impact on the usability because it makes actions easier to find and easier to trigger. This is why we've added tons of new features here with quick tools, tool sections, search or even the support for shortcuts. We've also made it easier to create good-looking edges with um auto-connected edges.

So you start creating an edge and you aim at the center of your target and we will create an auto-connected edge which will try to take the shortest path to its target at all time. You can move your node after that and we will move the edge to take the shortest path. This is a good example of how small interaction improvement can have a strong impact with

uh the comfort and efficiency of uh the application. Of course, you still have the ability to control exactly how your edge uh will behave if you want something more explicit. So, with the manual connect, you just have to aim at the border of your target, and we will remember where you want the edge to be attached. You can move the node, and we will make sure to

keep the edge attached to the same location. Of course, you can switch from manual anchoring to the auto-connected one anytime you want. Once this connection is created, the next step is to give user more control over the final layout of the edge. For that, you can move individual segments of the edge to improve the readability of the diagram without having to redraw everything. Beyond editing itself, another

important question is understanding the consequences of a change. And we introduce impact analysis because impact analysis uh helps users see how modification can affect the rest of the In complex systems, changes are rarely isolated, so this kind of feedback is really important to support safer decision for the end user. We also continue to improve the visual expressiveness of diagrams with the appearance of the nodes. So, the

specifier has always been in charge of the appearance of graphical element. Now, the end users can change the result. Appearance customization gives more control over how model element are rendered. The end user can thus change the appearance of a node very quickly. We will remember this customization, and you can easily restore the default appearance for each individual property. So, here you can put a label in bold

or change the background color, for example. The same logic applies to links between elements. With the edge customization, we can support richer visual convention for relationships. You can also change the layout style of the edge. Here you can go from Manhattan to oblique very quickly. As diagrams become richer, managing complexity becomes more important. So, for that, you can manage the visibility of the diagram elements when your

diagrams grow in size and density. Users need to focus on what matters at a given moment without losing the overall structure of the model. So, the goal here is to help end users control this complexity instead of being overwhelmed with everything visible at once. Label management may sound secondary, but in practice, it has a huge impact on the readability of the diagram. If labels overlaps, move unexpectedly,

or become hard to edit, the whole diagrams quickly becomes frustrating. You can now move or even hide labels very easily. Of course, you can restore everything just as quickly. And once labels are better managed, it also makes sense to give users more control over them. So, you can resize labels to adapt the display of textual information to the situation. It's especially useful for diagrams with long names,

notations, where readability matters more than compactness. We have also um updated all the selection works in the workbench. End users have now more control of on its behavior. Previously, anytime you selected an element in the workbench, we tried to show it at the same time in every workbench views and representation. You could essentially only work on one element at a time. Now, each workbench view and representation

can have its own selection. You can select something in a diagram while viewing something else in the explorer while editing the properties of a totally unrelated element in the detail view. You can, of course, reveal your current selection in overviews to find quickly what you need. So, this improvement has a strong impact on the overall editing experience. All these um rich interactions would not be useful without

strong performance improvement underneath. So, one major step forward was uh the update of the Sirius GMF JSON format we're using. Uh it made loading and saving semantics models dramatically faster. As you see, for example, a model with um 200,000 semantic elements that used to take around 40 seconds to open can now load in just over half a second. And even very large models with more than 1

million elements can now be opened in only few seconds. And since saving happens continuously during editing, this also makes the whole experience much smoother and much more responsive. We have also added uh filtering capabilities directly in the explorer view. So, this capability already existed through keyboard shortcut, but it is now much easier to access thanks to a dedicated button in the toolbar. So, end user can activate

filtering more naturally and quickly limit the visible content of the explorer to what matters to them. Beyond speed, another very important topic is diagram readability. And readability is a primary concern in modeling because a diagram is not only something you edit, it is also something you review, discuss, and share. So, recent updates have improved link routing with smarter algorithm for Manhattan and oblique paths as you saw.

Uh we have better layout stability and clearer handling of labels and intersections. So, the result is a diagram stay more legible and more professional-looking wizards requiring constant manual adjustment from users. A good example of that is how we now handle edge crossings. Here, the goal is to make interactions easier to read when many links are crossing each others. For that, we've added some white space around the

intersection of the edges. This may look like a visual details, but in dense diagrams, it makes a very real difference in readability. Another very important improvement was the support for more advanced type of relationships. With edge-to-edge connections, uh we can uh display notations where a relationship can target another relationships. This gives more expressive power to the editor and support more advanced graphical semantics. So, here for example,

we have uh an input which is listened by uh data fetcher over a specific uh network channel. So, here is the HTTP communication. And we can thus have this channel edge which has uh source uh which as a source is using another edge. We also wanted to give users more direct control over the layout of the edges. So, editing the path of the edge gives user a

final level of control over the final layout. This helps preserve readability in dense diagram without forcing them to fight against the automatic routing. Once again, the idea is to combine smart default with explicit user control. Another way to improve readability is simply to make better use of screen space. And that is the idea with by the compact layouts we we implement. It reduces unnecessary white space in

diagrams so user can see more information at once without losing clarity. And this is particularly useful in real projects where diagrams often need to stay readable while uh covering a large amount of content. So, we implement two new layouts, the flow layout and the compact layout. once a tool becomes more mature for editing, the next challenge is a scaling reuse across projects. As models grow in size,

modularity becomes essential. And with libraries, Sirius Web now makes it possible to define common components or shared assets in one place and reuse them across several projects. So, this avoids duplication, supports better governance, and introducing libraries helps organizations build a more consistent and scalable modeling environments. So, let's look at what it means in details. With libraries, tool builders and end users can reference shared content instead of

duplicating it. This helps maintain consistency, preserve data integrity, and create a stronger single source of truth across projects. Another benefit is that reuse does not mean losing control. You can create a library from a project, publish it, inspect it, and finally import it in another project. Once reuse is in place, another major topic is everyday productivity. To support daily use, we introduced several improvements focused on helping

users work faster and with less friction. So, this will includes global search, for example, through the omnibox on the top the workbench, a dedicated search view, some bulk actions are introduced also on multiple elements. You have faster navigation between representations and a more direct access also to common operations. Each of these changes may look as I said, small on its own, but together they save a lot

of time, especially in large and complex So, a first example is the search view inside of the project itself. So, with this view, end users have a dedicated place to find elements, diagrams, or other artifacts very quickly. And from an end user perspective, this changes the experience quite a lot because it turns navigation into a much more direct and intentional action. We've also improved quick access to

commands and elements through the command palette. So, this command palette is a very efficient way to navigate and trigger actions quickly. Users can open it with a shortcut, search for any element by name, even if it's hidden in the current representation, and access it very quickly. It can also be used to trigger actions to change the data that are inside of the project. And once a search

was well inside one project, the next logical step is to extend it across projects. With the cross-project search, we can perform this kind of search in the main project browser and in one click navigate directly to the model element we want inside of the project. So, instead of thinking in isolated workspaces, user can locate information across a broader working environment. Another new workflow is duplicating existing content.

We've added this capability to duplicate semantic element or representation directly from the explorer. This include options to duplicate the contained elements, preserve outgoing references, or even update incoming references, which make it much easier to replicate complex data structure very swiftly. We've also improved the the workflow in selection dialogues. So, now we're using a tree structure in selection dialogues to make it much easier to browse and choose

the right element in a structured way because you can see the context in which the element is located. You can see select one or multiple elements depending on the context of your interaction. So far, we've mostly looked at improvements for end users. So, let's now switch to the studio makers. I mean, people building really the modeling tools. And on that side as well, a lot has happened

recently to make the platform more flexible, more expressive, and easier to adapt to specific needs. One of the major steps forward serious web is the addition of new ways to explore and edit models. So, this is very important because diagrams are powerful, but they are not always the best answer for every every task. So, we introduced new representations that complement diagrams. One of the first major additions

on the studio maker side is a tree A diagrams remain very powerful, but they are not the most efficient way to explore deeply structured models or large volumes of elements. The tree representations provides a dedicated hierarchical view of model elements. And this is important. It is not just a project explorer. What we introduce is a real representation, which means user can interact directly with the model from

there, rename elements, create new ones, or reorganize the content. It could also stay synchronized with all the selections Stefan showed before. And so users can move naturally between the different views, diagram, trees. So, let's look more in details at what this tree representation brings. From a technical point of view, this is a real serious web representation, not just another navigation widget. It means it can be configured

by the specifier with the same modeling logic and integrated naturally inside of the workbench. It gives user an efficient way to browse and edit the model structure directly, especially when hierarchy matters more than layout. And for some use cases, even a tree is not the most natural representation. That is why serious web also introduced table representations. For many [clears throat] engineering tasks, for example, a grid-based view

is simply more useful than a graphical one. Um especially when users need to inspect or compare structured data. So, this makes the platform supports both visual and data-centric ways of working with for for working with the model. So, intro we introduce diagram trees and the tables and yes, can show that maybe. So, on the implementation side, tables already come with a rich set of capabilities. They support

uh for example, column filtering, hiding columns, resizing rows and columns, exporting content in CSV. They can also be extended with custom widgets and this is important because it makes table not just passive view, but a real working environment for users who need to inspect and manipulate structured data efficiently. In addition to this new representation, we continue to to improve the overall flexibility of the platform for studio

makers and the objective is to make sure they're more adaptable, so tool builders can shape representation more closely around their users' needs. we will introduce a new way for users to inspect and explore the model more directly with the query view. It allows end users to write AQL queries directly inside of Sirius Web and evaluate them using the context of their selection. It's useful for exploration, validation,

debugging or even advanced model analysis because users can rely on variables such as the current selection uh element in case you have multiple selection elements selected. You can now update the behavior of your representations without leaving your web browser. In a second click, you can fork the description of your representation and change it. Here, we can start with a diagram with large gray nodes uh containing all

sorts of elements. We can switch to a new version of its description in a studio project. Once we are in the studio, we can change the behavior of this specific instance of our diagram. We can change anything. For example, the background color of the gray node and switch it to blue. And we can go back to our diagram and see the result dynamically. In a couple click,

we have updated the behavior of our diagram without leaving the web browser. Using this mechanism, you can change anything, appearance or behavior. You could add new kind of nodes of edges or even new tools in the palette. So far, we have looked at end users and studio makers, but we don't forget developers. For developers as well, Sirius Web has evolved a lot. Here's a focus is to

make the platform easier to extend, easier to integrate, technical and organizational context. So, one specific aspect of that flexibility is the support for internationalization. It's important because many Sirius Web-based tools are used in a multi-language environment. So, supporting it properly means making the workbench easier to adapt in different It's also easier to integrate in products that need to address a wider audience. Another very important step was

giving developer more control over what is visible and available in the user interface. So, with capabilities, we have a fine-grained user interface control system, which means the workbench can now be configured more precisely depending on the use case. So, here we have a a version of Sirius Web initialized with some data and after that we have disabled all the editing You can't create new project, you can't

delete existing one, you can't update the data or the representation. You can't change anything, but we have initialized everything before. And this broader trend continues with more advanced customization option for tool builders. Sirius Web now offers more flexibility on several dimensions, style customization, dynamic UI behavior, project specific views, and global easier branding integration. This means teams can go much further in aligning the workbench with their own

domain and their own corporate identity. So, the platform is not only more powerful technically, it is also more adaptable as a product foundation. Another key topic for developer is integration. Sirius Web now provides improved GraphQL endpoint, REST API, and new front-end extension points to add custom React components or widget to customize the front-end. There's also an official Docker image now. So, overall the platform is becoming easier

to connect, easier to extend, and also easier to deploy. And finally, all of this also has to work at scale. So, beyond individual features, Sirius Web has continued to progress as a platform that can support larger models, larger teams, and more demanding usage conditions. Several improvements were introduced to make Sirius Web more robust and more responsive in larger environments. And for example, on the front-end side, virtualization

means the UI only renders what is actually visible, which keeps interactions fluid even with thousands of elements, especially in the query and the in the search views that we saw. Uh A large explorers also and lists also use progressive loading, no? So, only the relevant subset of data is fetched at a given time. And on the back end side, we work also, for example, memory management and

weak race handling were optimized, while deployment was made very easier with the official Docker images. And we also improved some Kubernetes oriented configuration to be sure that it could work for different kind of deployment. So, a good example of productivi- productivity at scale is the introduction of batch tool. So, with batch tool, it is now possible to apply the same action to several selected elements at once.

It's very useful when users need to perform repetitive modification across a large part of the So, at this point, we've seen a lot of progress inside the platform itself. So, let's now step back and look at the bigger picture. Sirius Web is not evolving in isolation. What makes it especially interesting is the ecosystem growing around it, and the way improvements in the core platform benefits broader family

of tools and use cases. So, this is where Sirius Web and Obeo Enterprise for Sirius really come together. Sirius Web provides the open source core building blocks. Obeo Enterprise for Sirius builds on top of that foundation with enterprise grade capabilities such as advanced security, scalability, and dedicated support also. And together, they support a wider ecosystem of solutions, including tools like Cesson, Papyrus Web, Smart EA, and the

latest version of ESA's ground and space segment engineering framework. So, the same core platform can power both open innovation and industrial production. A good way to to see the that the is growing and um um the ecosystem in practice is to look at the variety of tools already built with SiriusWeb. And the SiriusWeb gallery is available on the website. It illustrates the diversity of use cases supported

by the platform. It shows that SiriusWeb is not tied to a single domain, a single notation, or a single product shape. Instead, it acts as a common foundation that can be reused to build very different kind of modeling And this brings back to Obeo Enterprise for Sirius. Um it extends SiriusWeb with capabilities that are specially important in enterprise context. And the idea is not to replace SiriusWeb,

but to complement it with additional features that address operational, organizational, and collaborative needs, in fact. So, Obeo Enterprise for Sirius is really the enterprise layer that helps teams move from the open source platform to a production-ready environment. So, to understand that better, let's look briefly at the Obeo Enterprise for Sirius architecture. Archi- um on the architectural side, it builds on top of SiriusWeb like an extension and

adds enterprise-oriented services around it. The core idea is to preserve the openness and extensibility of the core platform while providing additional layers for governance, security, collaboration, and deployment. So, from a technical point of view, it's really just an extension of the SiriusWeb foundation rather than a disconnected product. And from that uh architecture, Obeo Enterprise for Sirius introduces a set of features in that enterprise usage. First of

all, authentication support with OAuth 2 or username/password. Webhook integrations. and visual collaboration to prepare the platform for more advanced capabilities in the future. So, here you can see that if we interact with the widget in the detail view, we can see the avatar of the various users who are typing or selecting something in a text field or in other widgets. So, a a first key capability in

Oberon Enterprise for series is the way it structures access and collaboration. We introduce organizations and organizations provide a shared workspace to structure teams and to control access to projects in a way that it is quite similar to get up organizations. They give a clear parameter for grouping related projects and our common ownership model. And they make collaboration easier to scale while keeping responsibilities clear. So, instead of

managing access user by user in an adequate Oberon Enterprise for series provides a much more structured and sustainable model. And of course, we're not stopping here. This was the past. And now there's the the future also. So, what we're working on looking at, there are three major directions we're exploring. The first is advanced collaboration with real-time multi-user editing, visual presence such as multi-cursor support and version management

also. The second topic is assisted modeling especially through AI-powered support for model generation, refinement, and global consistency checking. And the third is UX continuity, continuing to bridge the gap between the power users expect from usual desktop tools they are used to to And the simplicity is they expect from web applications. As the platform grows, documentation also becomes more important and good documentation is essential for both end

users and developers. It help people discover features and understand how to use them and adapt the platform more efficiently. So, the documentation website for Service Web will first be available in the upcoming weeks. Another important features in Oberon Enterprise Process here will be support for discussion directly in the workspace. So, comments make it possible to attach feedback and discussions directly to the relevant project context and so

to for example a specific semantic element. And this will help teams centralize exchanges, preserve the rational behind decisions when they are modeling and and also also it's avoiding spreading important discussions across too many external tools. Another direction as I said we're exploring is AI integration. AI can help users create, refine and complete model elements more efficiently and it can also accelerate repetitive tasks such as documentation and

it's also can provide more relevant guidance by using the project and model context. So, here again, the objective is not to replace modeling but to make the platform more helpful and more productive for users. And from a technical perspective, this can open several interesting direction. One possible direction is to rely on MCP server integration to connect AI assistant to external tool, services and project data in a

standardized way. Another solution just to introduce custom skills tailored to specific domains or project task. So, the assistant can provide more relevant and more contextual support. So, the longer term perspective is not just generic AI, but domain aware assistance that fit naturally into the Sirius and Obeo Enterprise for Sirius environment. So, here I'll just speed up the video. Can be a bit long because in this version

it did not refresh while the AI was working. It was only refreshing at the end. So, here you can see that we can ask the AI to uh perform some changes in the model. It will tell us what it has uh done and create both semantic elements and graphical ones inside of the diagram that uh we opened. And specifically this one. We can also query the state

of the project and it can use the current selection of the workbench to um help us understand specific elements. we really value your feedback because it helps shape the future of Sirius. Our road map is adaptative, which means we continuously adjust our priorities based on what matters most to users and adopters. So, in the upcoming months, both Sirius Web and Obeo Enterprise for Sirius will continue to

evolve according to the needs and interests we see from the community, from the real project. So, if you have ideas, expectation, or concrete needs, this is the right time to share that with them with us. And uh we also welcome contributions from com- com- the community as well as sponsorship opportunities because all these inputs is really essential to help Sirius project grow in the right So, to

conclude, Sirius Web has reached a new level of maturity. It is now a true multi-representation platform with diagram, trees, tables, and it is much better prepared to support enterprise scale models and demanding usage scenarios. And with Oberon Enterprise Pass series on top of it, there is no clear path from the open source innovation to the industrial production also. And with that, we've reached the end of the

presentation. Thank you very much for your attention, and we'll be happy to take your questions. >> [applause] >> I have actually two questions about the new presentations. Uh first, the Uh do you Can you make as a viewpoint specifier preconfigured queries, such as query templates, that you have a user can reuse, or is it a vanilla for every user? You can't provide query templates, but you can

provide additional services, which can embed a complex behavior in term of navigation inside of the model, just like you could register custom Java in other part of the AQL support. It can also perform modification. It's not just the queries, the read-only query. Okay, and the second question was about the table representation. Uh are the bulk editions and the batch batch editions tools that you mentioned in the

table representation, because it's often the use case when you have list of elements, and you want edit a selection all at once. Right now we are improving the multi-selection support mainly in diagrams and the explorer. So no, it's yet extended to the table representation. But in table representation you can contribute specific services and toolings that could be applied to all what you decide. So this could be

possible with some some developments but not so much. Thank you. You're welcome. Thank you for the presentation. I got first question very easy. Sirius Web, what is the license for it? EPL V2 just like pretty much everything in the Eclipse Foundation. >> Yeah. Um second thing about the enterprise you you you just show us. Is it possible to get it on prom? Yeah, definitely. That's the purpose.

Okay. It's just an extension of Sirius Web so any Sirius Web based application whether it's Sirius Web or Cison or the enterprise versions of you can use them on premise, you can use them in the cloud. We don't have any constraint on the deployment. Second question is that if we have already some I would say legacy application using a Sirius the classical Sirius or the legacy Sirius,

how much is it to to to migrate to Sirius Web? So you need to discuss that with the CEA because they did that with Papyrus. Um you we don't have something which helps you automatically do that. Um you need to reuse what you develop with Desktop to re-implement things with Sirius Web but um it's go much faster because you can reuse lots of thing if you organized

your tooling correctly all those Java services, your EMF models are still the same and you will have to recreate mostly the same kind of old design, but this one you can now create thanks to Java API. So, it's quite easy and even if you want to do that, you can script that quite easily. But, it will take some time. It's not a It's a project. Yeah. >>

[laughter] >> It depends on the complexity of your and the level of customization you add in the desktop application. So, as Melanie said, your metamodel, Java services, things like that, it's very straightforward. If you add, for custom user interface, custom dialogues, or things like that, you will need to build those using React components and front-end technologies and think about back-end and front-end communication. So, it depends on

the complexity of the customization you did on Sirius Desktop. Thanks for the presentation. A need I found in practice is often that I have diagram wide preferences with respect to appearance options. Something like in in old Papyrus we used this uh cascading style sheet. So, for instance, I want to hide generally the labels of connectors. Is it planned to to have something like a diagram wide configuration

of certain appearance options? So, not yet. There is not a configuration like that in diagrams, but we are adding some more features available on the diagram like the capability to hide all the labels. So, this should exist in the next version, next release, I think. I think it's on the table right now. I'm not sure if it's right now or for the I think it's on >>

one after it's on development so it should arrive with the June release. So thanks it's time to finish. >> We have 30 seconds to finish. So thank you all. Thanks for your question. We are available at our booth to to discuss more after that so do not hesitate. Have a nice day. Thank you.