Modelio features

The functional and ergonomic richness of Modelio will amaze you!

It may take you some time to discover all Modelio's many features, but you'll immediately feel its simplicity thanks to its well-known RCP/Eclipse-style ergonomics. And don't forget that using the module extension technique, you can configure Modelio for specific kinds of use in your own individual context.

It would be almost impossible to provide an exhaustive list of all Modelio features, but the table below presents some of the most important ones, organized by theme.

Available as standard
Available for purchase

	Open source Modelio distribution	Modelio commercial distributions
UML2 support
Support of UML 2 metamodel and notation
Class & package diagrams
Object diagrams
Composite structure diagrams
Use case diagrams
Sequence diagrams
Activity diagrams
Action semantics
State machine diagrams
Communication diagrams
Component & deployment diagrams
Profile diagrams
Goals, Requirements, Dictionary, Business Rules
Goal diagrams & spreadsheet edition
Requirement diagrams & spreadsheet edition
Business rule diagrams & spreadsheet edition
Dictionary diagrams & spreadsheet edition
Business Process Modeling, Enterprise Architecture, SOA Architecture support
Organization diagrams
Organization role diagrams
Process overview diagrams
SOA architecture diagrams
Business geographical deployment diagrams
Hardware architecture diagrams
Hardware deployment diagrams
BPMN diagrams
MDA support - UML extensions (profiles and diagrams)
Construct and use your own custom diagrams based on UML diagrams. Customize UML diagrams.
Define UML profiles (modeling & creation)
Create stereotypes on the fly
Customize stereotypes, constraints, tagged values
Use stereotypes as icons
Filter extension elements (tags, constraints, stereotypes) and UML modeling elements
Access the metamodel: documentation, Java API
Use MDA customization wizards: Java framework creation, user-made Modelio module automation
Define packaging for extensions, diagram definition, model transformations, Java tooling: modules
Deploy modules in Modelio environments
Write scripts using the Jython scripting language. Use the batch mode for MDA execution.
Editor operations
Use smart actions to quickly create elements by drag & dropping within target diagrams or model elements
Use smart interactions to default create the best suited kind of element within a choice
Use the name completion mechanism for model element referencing
Drag & drop for namespace change, element referencing (i.e. typing)
Direct element designation for referencing (three possibilities: completion, drag & drop, direct click)
Hyperlink support: define your own model element/diagram navigation rules
Use complex element edition wizards (when creating operations or parameters, for example)
Cut/copy/paste elements
Undo/redo mechanism, unlimited until save/quit
Zoom to selection, fit in page, zoom-in and zoom-out with customizable zoom factor control
Put diagrams in full screen mode. RCP mechanism.
Control element placement and manipulation - signs and notes instantly warn against impossible operations or placements
Directly edit text in diagrams for model element names
Draw several items of the same type using the sticky button
Automatically synchronize related model elements
Have multiple views of the same model element
Export all diagrams into several image formats (PNG, WMF)
Colors and formatting
Customize UML element views (pen color, fill color, font)
Customize element properties (show/clear stereotype names)
Use project templates: Define presentation options for your projects.
Define individual styles for stereotypes. Apply different presentation styles to elements depending on their diagram type.
Consistency checks
Real time consistency checks
Guarantee your models are properly built through more than 280 consistency checks
Directly jump from an error to the related "inconsistent element"
Run consistency checks on demand
Analyze dependencies and circular dependencies in real time
Customize consistency rules in a graphical editor
Browser
Manage model structure via tree-like interface
Use fact creation shortcuts
Access operation menu quickly (including edit specification, change name, print diagram, and others) for model elements
Filter out unessential elements
Sort model elements by name and type
Different model view in the browser and the diagrams
Model and diagram search engine
Use Quick Find in the browser
Search for regular expressions
Modeling facilities
Use project templates
Use smart instance creation, by dragging a classifier into an instance context (such as an internal structure or a collaboration, or an interaction/sequence diagram)
Create custom setters and getters for class attributes and association ends
Generate overridden/realized operations
Drag a class from browser to sequence diagram to create a lifeline
Select operation for message in sequence/communication diagram
Model decomposition
Use native model import/export feature
Use "model components" to deliver parts of projects to other projects
Manage "model components" for importer projects: read-only components, GVC/CMS ignored by the importer project, dependencies/versioning compatibility management between model components
GUI
Perspectives - the GUI adapts itself to the selected modules or MDA components (e.g. becomes Java specific, C++ specific, analysis specific, …)
RCP ergonomics – Eclipse-like, with dockable windows, …
Use project creation wizards: configuration help, predefined project configurations
Use quick property tab enabling fast editing of selected elements
Layout
Align and center symbols
Use the automated diagram layout feature
Resize selected symbols to identical dimensions
Choose between two line drawing options: orthogonal or "free"
Java 7.0 support
Check for errors in the model against Java language rules using the model syntax checker
Generate ANT application production
Generate model-driven Java code
Choose between two code generation strategies: model-driven and roundtrip
Preserve all comments and method implementations during roundtrip engineering
Reverse engineer Java source code
Use JavadocTM tags during both the reverse engineering and code generation phases
During reverse engineering, collect Javadoc comments in code and store them as documentation of the model element
Add JavadocTM properties, such as @param, @author, when generating code
Customize file header text (e.g. company copyright information)
Automatically generate "import" sentences (optional)
Manage project sharing for Java: export Java-accessible interface or class definition with model components
Customize Java code generation
Generate smart model-level method implementation
Use the integrated colored syntax editor
Use smart accessor generation at model level
Generate array/vector/hashtable, or other container types for association/composition multiplicity greater than one
Reverse engineer Java bytecode files (.class, .jar, .zip)
C++ model-driven code generation
Reverse engineer C++ source code
Generate makefile code
Generate C++ source code from static structure diagrams
Synchronize code/model using the synchronization mechanism
Check for errors in the model against C++ language rules using the model syntax checker
Generate ANSI C++ 2003 templates
Automatically calculate "import" and generate optimized #include directives
Generate separate .h and .cpp files
Generate optional array types, or other container types for aggregation/composition multiplicity greater than one
Use smart accessor generation at model level
Customize code generation
Choose generation for predefined libraries for C++ (STL, ...)
Parameterize the end-user C++ library
Collect C style comments in code as documentation of the model element
Use support of enumerations
.NET reverse engineering and code generation
Reverse engineer C# source code
Generate C# source code from static structure diagrams
Reverse engineer C# assembly
Reverse engineer executable files (requires that a disassembler be installed)
Documentation generation
Generate documents in HTML format
Generate documents in Word 2007 (open XML) format
Generate documents in LibreOffice format
Customize document generation through a set of predefined document templates covering the entire lifecycle
Compose documents by combining different document templates applied to several model parts
Document roundtrip: integrate notes entered in MS-Word into your model
Diagram images embedded in reports: JPG or PNG formats
Generate hypertext links in documents
Teamwork management
Convert existing local projects into teamwork projects
Use safe locking team cooperation management
Automate team configuration update: everybody has the same consistent version of "model components" and model extensions/modules
Check in/check out/update synchronized with the server
Use project versioning and rollback support
Use project branching
Manage project access permission
Use parts of other projects (model components). Ignore these imported elements in local CMS actions.
Work in offline mode
Integrate the Subversion open-source CMS tool in Modelio
IDE integration
Automatically synchronize code and model, plug to external IDEs (Visual Studio, Eclipse, NetBeans, ...)
Integrate with Eclipse 3.1 or later (JDT or Java IDE)
Open API
Access all UML metamodel classes
Add, remove, query diagram presentation elements
Change presentation element properties
Create a new diagram type extending existing UML diagrams
Insert actions into menus, toolbars, or context menus
Import/export projects
Add dedicated model element specification dialogs
Write your own Java and add plug-ins
Export diagram images using open API
Create new transformations
Other
XMI 2.1 - EMF compatible import
XMI 2.1 - EMF compatible export
Easily migrate to new version releases. Previous program settings are retained.
Use the "Submit an issue" dialog. Send your bug descriptions directly to the Modelio support team.
Read tooltips for the most important GUI components
Watch Modelio video tutorials
Use general help system with internal search
Choose floating license to use the same license on multiple machines