Why we need modern Domain Modeling tools: the origin of Structura
2026.01.20
Seville, Spain
The gap in modern engineering
Software development has reached an extraordinary level of technological maturity, but the engineering that supports it still relies on tools from the last century.
We design distributed, collaborative, regulated systems… and yet, most teams still manage the structure of their software the classes, entities, and relationships that sustain it using static diagrams or fragmented documentation.
At Metadev, we have seen it again and again: teams that start off strong, with well-chosen frameworks, solid conceptual models, and good energy… until the first major iteration arrives. Then the code grows, dependencies intertwine, and the models become unrecognizable. What was once a clear architecture turns into a set of implicit, ad hoc decisions not always consistent, depending on each developer’s preferences or style.
“We keep modeling 21st-century systems with 20th-century tools.”
And that gap is not just aesthetic; it is operational a gap between design and software reality that generates technical debt.
The problem: the software domain and architecture are neither visible nor shared
Every system has an internal structure a way of organizing its components and relationships but in most projects, that architecture and domain remain hidden within the code.
- Diagrams, if they exist, quickly become outdated.
- Architectural decisions remain in conversations or in the minds of a few engineers.
- Documentation too often becomes something done “at the end, if there is time.”
The result:
- Small changes that cause side effects and degrade system quality.
- Teams that lose time trying to understand their own code.
- Brown-field maintenance that becomes slower and more expensive than green-field development.
- And in regulated environments, a total loss of traceability.
What’s needed: a new generation of tools that bring vision and coherence
Modern engineering doesn’t need more documentation; it needs living, executable models models that accurately reflect the software domain and architecture, and evolve alongside it.
A modern modeling tool should:
- Allow visual and textual modeling, enabling clear design and precise automation.
- Be collaborative, integrated with real repositories and workflows.
- Generate reliable and auditable code artifacts, not mockups capable of applying best practices, following organizational coding conventions, and ensuring compliance with regulatory policies.
- And above all, connect design, validation, and execution without semantic loss.
In other words: the model should not be a drawing or documentation, but the source from which all other software artifacts derive.
The answer: Structura
Out of this need comes Structura, a web environment for editing class models both graphically and textually, combining technical rigor with accessibility.
Structura is based on:
- Daga, our visual editing library.
- Essential, a formal metamodel defining how software structures should be represented.
The result is an editor that allows you to:
- Represent classes, associations, and inheritance with UML-style visual notation.
- Review and version models as code (Git-compatible).
- Generate ad-hoc, customizable code based on stack or domain.
- It will also include AI assistants to support model creation and explanation but not during generation, where we prioritize deterministic code generation to ensure certified quality at all times.
The story behind it: Metadev’s vision
Structura is not a starting point it’s a consequence.
We work in model engineering, code generation, and regulated environments, from industrial systems to defense and aerospace. Through that journey, we’ve learned something essential: tools matter when they help us think better focusing on what’s essential, discarding irrelevant details, and choosing the right level of abstraction for the work.
First came Apricot, our editor for SysML v2, which opened a new stage in systems modeling.
Now, with Structura, we take the next step: bringing that same precision to software modeling.
Both tools share one principle: engineering must be based on formal, validatable, versionable, and executable models.
Building on what we design
Modeling is not drawing. Modeling is shaping technical thought making it shareable, communicable, with precise semantics, maintainable, and automatable.
The future of software will be increasingly domain-oriented.
And to get there, we need tools that allow us to model the domain as a potter shapes clay giving form to the foundation of the system’s knowledge.
Structura was born from that conviction from the need for engineering models to be clear, auditable, and alive (executable, actionable).
Technical specification
Tool Type
Graphical and textual editor for class modeling (UML)
Core Technologies
Daga (visual engine), Essential (metamodel library)
Visual Modeling
UML notation: classes, enumerations, associations, inheritance, decorators (stereotypes).
Textual Modeling
Concise syntax, human and machine-readable. Compatible with version control workflows (e.g., Git) and designed to facilitate automation.
Collaboration
Real-time concurrent editing (multi-user mode).
Versioning
Compatible with version control systems (like Git) through textual model representation.
Code Generation
Supports ad-hoc code generation, customizable by stack or domain. Deterministic, capable of ensuring and certifying the quality of the code by design.
Deployment
Available as a web application (SaaS) or on-premise installation in secure environments.
Use
Software engineering, class and relationship modeling, support for traceability and validation.
Integration with Metadev
Structura shares technological foundations with other Metadev tools, such as Apricot, within the model-based engineering (MDE) ecosystem. SysML2 is available as exporter.
Try it
Structura is available as a web version to explore directly from your browser: Structura
Check the technical documentation to learn more about its capabilities and first steps.
We’d love your feedback: send us your comments or suggestions.
Your experience helps us keep improving the tool.
Metadev — Simplifying the complex.