StarUML
StarUML is a sophisticated, multi-platform software modeler developed by MKLabs for agile and concise modeling in software development. It fully supports the UML 2.x standard and SysML, along with additional diagram types such as entity-relationship diagrams (ERD), data-flow diagrams (DFD), flowcharts, C4 models, mind maps, and cloud architecture diagrams for AWS, GCP, and Azure. Targeted at professional developers, small agile teams, and educational institutions, StarUML provides a modern user experience with features like dark and light themes, high-DPI (Retina) display support, multiple windows, and extensibility through JavaScript-based extensions for custom functionality.[1] The tool originated in the mid-2000s as a Windows-based UML modeling application that achieved widespread adoption. After the original project was discontinued, development resumed in 2014 with StarUML 2, introducing a new technology stack focused on cross-platform compatibility (macOS, Windows, and Linux) and enhanced performance. Subsequent major releases have built on this foundation: version 3 (2018) added DFD support and automatic updates; version 4 (2020) incorporated SysML and Touch Bar integration for macOS; version 5 (2022) enabled native Apple Silicon support; version 6 (2023) introduced C4 modeling and cloud diagrams; and the current version 7 (released July 2025) integrates AI capabilities via MCP servers, Mermaid diagram generation, and expanded Azure architecture support.[2][3] Key capabilities of StarUML include model-driven development with open APIs for third-party integrations, export to HTML documentation, asynchronous model validation, and code generation for languages such as Java, C#, C++, and Python through extensions. It operates under a proprietary license with a 30-day free trial, after which a one-time purchase is required for a perpetual license to continued use of advanced features, making it suitable for both individual professionals and team environments seeking efficient, customizable UML and SysML modeling.[1][4][5]Introduction
Overview
StarUML is a proprietary software modeling tool designed for creating and managing visual models in software development projects. It supports the Unified Modeling Language (UML) 2.x standard, along with other notations such as Systems Modeling Language (SysML), Entity-Relationship Diagrams (ERD), and Business Process Model and Notation (BPMN), enabling users to represent complex systems through standardized diagrams.[6] The tool emphasizes agile and concise modeling practices, providing straightforward interfaces to simplify the creation of models without the overhead of more complex alternatives.[6] Its primary use cases include software engineering for designing application architectures, requirements analysis to capture stakeholder needs, and model-driven development (MDD) workflows where models serve as the basis for code generation and system implementation.[6] By facilitating these processes, StarUML helps teams visualize, document, and validate system designs early in the development lifecycle, reducing errors and improving collaboration.[3] The current version, StarUML v7.0.0, was released on July 16, 2025, introducing features like device-based licensing for clearer management of installations across multiple machines and enhanced cross-platform compatibility for Windows, macOS, and Linux.[3][4] At its core, the tool is built on the Electron framework for developing desktop applications, allowing extensibility through JavaScript, while models are stored in a simple JSON format to support easy integration and custom code generation via command-line interfaces.[7][6] Originally evolving from an open-source project, StarUML has transitioned to a commercial product while retaining its focus on flexible modeling capabilities.Development and Platforms
StarUML is developed by MKLabs Co., Ltd., a South Korea-based software company founded in 2014 by Minkyu Lee, Ph.D., who serves as its CEO.[8][9] The tool's initial origins trace back to Plastic Software, Inc., which developed early versions of the software starting in 2001.[10] Since 2014, StarUML has operated under a proprietary licensing model governed by the StarUML End-User License Agreement (EULA).[11] A free evaluation version provides a 30-day trial for new users, after which paid licenses are required for continued use.[4] Licensing options include the Standard edition at $129 per device for basic UML and diagram support, and the Professional edition at $199 per device for advanced features like SysML and BPMN; both follow a one-time payment model with volume discounts for multiple devices.[5] In version 7.0.0 released in 2025, MKLabs introduced a device-based licensing model, shifting from previous user-based restrictions to allow perpetual use on licensed hardware without recurring fees.[3] StarUML is a cross-platform desktop application built on the Electron framework, enabling native execution on macOS, Windows, and Linux operating systems.[12] It requires macOS 10.13 or later, Windows 10 or later, or compatible Linux distributions, with an underlying Node.js runtime for core functionality.[4] Native support for Apple Silicon (ARM-based) processors was added in version 5.0.0 in 2022, providing optimized performance on modern Macs without emulation.[13] The development approach emphasizes extensibility through JavaScript modules, allowing users to create custom extensions, commands, and integrations via open APIs.[7] StarUML includes an auto-update mechanism to deliver new features and fixes seamlessly, configurable in preferences.[6] Additionally, a command-line interface (CLI) introduced in version 5.0 supports automation for tasks like code generation and diagram export without the graphical user interface.[13]History
Early Development (1997–2005)
The origins of StarUML trace back to 1997, when it began as Plastic, a software tool developed by Plastic Software Inc. in Seoul, South Korea, initially supporting the Object Modeling Technique (OMT) notation for object-oriented modeling.[14] Plastic 1.0 was released as freeware that year, providing basic capabilities for drawing simple diagrams to aid in software design processes.[14] By 1998, Plastic version 1.1 shifted its focus from OMT to supporting UML 1.x standards, aligning with the growing adoption of the Unified Modeling Language as an industry standard for visualizing, specifying, and documenting software systems.[14] This evolution introduced support for key UML 1.x diagrams, such as class, use case, and sequence diagrams, while remaining Windows-only to target professional developers on that platform.[15] The tool emphasized rapid prototyping, enabling users to quickly construct and iterate on models without the overhead of more complex commercial alternatives.[15] A major milestone occurred in 2005, when the tool was renamed StarUML 5.0—building on the Agora Plastic branding—and introduced a modular architecture based on the Model-View-Controller (MVC) pattern to separate concerns between models (data structures), views (diagrammatic representations), and controllers (user interactions).[15] This design allowed for extensible components, such as add-ins and frameworks, facilitating customization and integration for diverse modeling needs.[15] The foundational work completed by 2005 paved the way for the first public release on August 7, 2006, marking the transition toward broader accessibility.[15]Open-Source Era (2006–2010)
In 2006, StarUML was released as an open-source project under the GNU General Public License version 2.0 (GPLv2) and hosted on SourceForge, marking a shift from its proprietary origins to encourage collaborative development.[16] The initial open-source version, internally designated as 5.0, became available in August 2006, providing a extensible UML/MDA platform primarily for Windows.[17] This release facilitated active community involvement through its modular architecture, which supported the creation and integration of extensions using languages like Delphi and C++.[18] During this period, the community contributed significantly to enhancing StarUML's capabilities, particularly through extensions for UML profiles that allowed customization of modeling notations and semantics for specific domains or methodologies.[19] For instance, developers added support for advanced diagram types, including improved state machine diagrams, enabling more robust behavioral modeling in line with UML 2.0 standards.[20] These enhancements made the tool adaptable for various software engineering tasks, with ongoing releases refining features like code generation and diagram validation until around 2010.[21] However, the project faced challenges due to limited funding and reliance on volunteer contributors, leading to slowing development momentum.[22] The last official open-source release occurred on July 19, 2010, after which maintenance ceased, though the codebase remained available for use and forking.[21] Despite these issues, StarUML gained considerable traction in academic settings and among small development teams for its cost-free access and flexibility in UML-based modeling.[23] Community feedback on SourceForge highlighted its utility for educational purposes and lightweight projects, with high ratings for features and ease of use.[24] This era's efforts laid the groundwork for subsequent forks that addressed ongoing needs in the open-source ecosystem.Commercial Revival (2011–Present)
In 2011, the open-source development of StarUML concluded, prompting community forks such as WhiteStarUML to maintain compatibility and features for legacy users. The original developers, after the open-source project stalled due to the closure of its sponsor, formed MKLabs Co., Ltd. led by Minkyu Lee, PhD, in South Korea and resumed development as a commercial proprietary product.[2] This effort culminated in the release of StarUML version 2.0.0 on December 29, 2014, which introduced a rewritten architecture with enhanced documentation generation, default color schemes, and automatic backups, marking the end of the free open-source era.[25][6] The commercial phase emphasized cross-platform compatibility and modern development practices. Version 3.0.0, released on June 1, 2018, transitioned the underlying platform to Electron, enabling robust multi-platform support across macOS, Windows, and Linux, along with features like multiple windows, data flow diagrams, and automatic updates.[26] This integration of web technologies facilitated extensible JavaScript-based extensions and improved user interface responsiveness. Subsequent updates adopted a perpetual licensing model, with one-time payments per device starting at $129 for the Standard edition and $199 for the Professional edition, which includes advanced notations; volume discounts and educational pricing further supported broader adoption.[27] Major version releases continued to expand modeling capabilities. Version 4.0.0, launched on October 29, 2020, added full support for the Systems Modeling Language (SysML), including requirement, block definition, internal block, and parametric diagrams, alongside new UML diagrams such as timing, interaction overview, and information flow diagrams.[28] Version 5.0.0, released on March 21, 2022, introduced native support for Apple Silicon processors and removed diagram size limitations, enhancing performance on modern hardware.[29] Version 6.0.0, issued on September 11, 2023, incorporated Business Process Model and Notation (BPMN) support, C4 architecture modeling, mind maps, UI wireframes, and architecture icons for AWS and Google Cloud Platform, with improved export options like enhanced HTML documentation.[30] Ongoing maintenance reflects a commitment to reliability and innovation. For instance, version 6.3.3, released on June 16, 2025, addressed key usability issues, including arrow key navigation for views, enhanced icon pickers for cloud architectures, and support for namespaces in frames.[31] The latest milestone, version 7.0.0 on July 16, 2025, implemented a device-based licensing system, added Mermaid diagram generation for text-to-diagram workflows, introduced Azure architecture icons in the Professional edition, and integrated AI-assisted modeling via the MCP (Model Context Protocol) server for automated diagram suggestions and validations.[32] These updates underscore a strategic focus on AI-driven efficiencies and cloud-native design tools as of late 2025.[31]Features
Supported Modeling Languages and Diagrams
StarUML provides comprehensive support for the Unified Modeling Language (UML) 2.x standard, enabling the creation and management of models compliant with its specifications. This includes 13 primary UML diagram types: class, package, object, composite structure, component, deployment, use case, sequence, communication, statechart (also known as state machine), activity, timing, and interaction overview diagrams, along with support for information flow and profile diagrams.[6][1] In addition to UML, the Professional edition fully supports the Systems Modeling Language (SysML) (introduced in version 4), a profile of UML tailored for systems engineering. SysML diagrams available include requirement, block definition, internal block, and parametric diagrams, facilitating the modeling of complex systems architectures and behaviors.[33][5] For data modeling, StarUML incorporates Entity-Relationship Diagrams (ERD) to represent database structures and relationships.[6][1] The tool also supports Data-Flow Diagrams (DFD, introduced in version 3) for illustrating data movement within systems and Flowchart Diagrams for visualizing processes and algorithms.[34][35][12] For business process modeling, the Professional edition supports Business Process Model and Notation (BPMN) 2.0 (introduced in version 6), which covers process, collaboration, choreography, and conversation diagrams for visualizing workflows and interactions.[6][36][5][37] StarUML accommodates additional notations in the Standard edition, including C4 models (introduced in version 6) for software architecture visualization and Mind Maps for organizing information hierarchically.[38][39][37] For cloud architecture, the Professional edition supports diagrams utilizing official icons: AWS and GCP (introduced in version 6), and Azure (introduced in version 7).[40][41][3][5][37] Furthermore, StarUML supports Mermaid syntax (introduced in version 7) for rapid generation of diagrams like class, sequence, state, flowcharts, entity-relationship, requirement, and mind maps directly from text-based descriptions.[3][42][6] A key capability is the integration of multiple modeling languages within a single project workspace, allowing users to combine UML, SysML, ERD, BPMN, and other notations seamlessly for holistic model development.[6]Editing and Customization Tools
StarUML provides an intuitive user interface for editing models, featuring a drag-and-drop canvas where users can create elements by selecting types from the Toolbox and placing them directly on diagrams.[43] The Toolbox offers categorized palettes of UML and other modeling elements, such as classes, actors, or frames, enabling quick addition to the working diagram.[43] Complementing this, the Property Editor serves as an inspector panel that displays and allows modification of selected elements' attributes, including names, stereotypes, constraints, and documentation, ensuring precise control over model semantics.[43] Additionally, the Explorer panel facilitates navigation and selection of model elements, supporting drag-and-drop operations to instantiate views on diagrams without manual toolbox access.[43] Customization in StarUML extends beyond standard UML through extensible mechanisms, notably JavaScript-based extensions that allow developers to add new commands, menus, and behaviors.[7] Users can create extensions by defining apackage.json manifest and an entry main.js file in a dedicated folder, registering custom commands via the application API—for instance, implementing a simple alert function with app.commands.register—and reloading the tool to apply changes.[7] For domain-specific adaptations, StarUML supports UML profile definitions, which enable the creation of custom stereotypes, tagged values, and notations to tailor the metamodel for particular languages or industries, effectively building domain-specific languages (DSLs) within the UML framework.[44] Profiles are defined using Profile Diagrams, where elements like Stereotypes and Tag Definitions extend base UML metaclasses, and once applied to a project, they integrate seamlessly into the editing workflow.[44]
Advanced editing capabilities include asynchronous model validation against built-in UML rules, which checks for compliance with standards such as ensuring edges into merge nodes are uniformly object or control flows (UML047).[45] This validation runs in the background, highlighting errors in the model explorer or diagram views to maintain syntactic and semantic integrity without interrupting the editing process.[45]
A distinctive feature available in the Professional edition (introduced in version 6) is Wireframe Diagram support, which provides a toolkit for low-fidelity UI prototyping with elements like buttons, text fields, checkboxes, and frames, allowing integration of wireframing directly into modeling workflows.[46][5][37] Furthermore, the Markdown Documentation extension enables embedding richly formatted notes within model elements, offering syntax highlighting and live preview for documentation edited in Markdown, enhancing readability and collaboration on diagrams.[47]
Export and Integration Capabilities
StarUML provides robust export capabilities for transforming UML models into various formats, enabling seamless integration with development workflows. Through its core features and extensible architecture, users can generate code in multiple programming languages, produce visual outputs, and create documentation artifacts. These exports are facilitated both via the graphical user interface and the command-line interface (CLI), supporting automation in continuous integration pipelines.[48] For code generation, StarUML supports forward engineering from UML diagrams to source code in languages such as Java, C#, C++, and Python, primarily through dedicated extensions available in its registry. The Java extension, for instance, enables modeling and code generation for frameworks like Java Persistence API (JPA), Hibernate, Spring, and Jackson, while also supporting reverse engineering to import existing Java code into UML models. Similarly, the C# extension handles .NET Core entities, and the C++ extension provides code generation and reverse engineering capabilities. Python support includes generation of models like Django and PeeWee from entity-relationship diagrams (ERDs). These extensions leverage Embedded JavaScript (EJS) templates for customizable output, allowing developers to produce production-ready code snippets or full modules from class, sequence, or state machine diagrams.[49][50] Visual exports include high-resolution images in PNG, JPEG, and SVG formats, which can be generated directly from diagrams using the CLI'simage command or via the GUI's export menu. This is particularly useful for documentation, presentations, or embedding in reports, with options for custom resolutions via extensions like Device Pixels Ratio for Export. Document generation covers PDF for printable diagrams with layout controls (e.g., A3 size) and HTML for interactive web-based documentation, both accessible through CLI commands like pdf and html. Additionally, XMI 2.1 export and import ensure standards compliance for interoperability with other UML tools, supported by a dedicated extension. Recent enhancements in version 7.0.0 (July 2025) expanded Azure architecture support for cloud modeling in the Professional edition.[48][49][31][5][3]
On the integration front, StarUML's CLI (introduced in v5.0.0) allows headless operation for batch processing, such as generating code or documents from model files (.mdj) in scripts or CI/CD environments, using commands like ejs for template-based outputs. AI integration, added as a pro feature in v7.0.0 via the MCP server, enables automated suggestions, code generation, and diagram creation by leveraging external AI models. Version control is supported through a Git integration extension, facilitating collaborative modeling with hooks for committing model changes. For IDE interoperability, extensions enable round-trip engineering: the Java extension integrates with Eclipse by generating and reverse-engineering code to keep models synchronized, while C# and Visual Studio Code linking extensions support navigation and updates in Microsoft ecosystems. These capabilities extend StarUML's utility beyond standalone modeling, bridging it with broader software development tools.[48][31][49]
File Formats
Native Format
StarUML's native file format is the .mdj extension, which encapsulates the entire project in a single, human-readable JSON (Model Diagram JSON) file designed for ease of parsing and integration with version control systems.[51] This format represents the project's hierarchical structure as a top-level JSON object, enabling straightforward access to modeling data across various programming languages without requiring proprietary parsers.[51] The JSON schema organizes content through key elements such as models, views, and owned elements, forming a tree-like representation that mirrors the application's explorer panel. At the root, the project object includes fields like_type (indicating "Project"), _id (a unique identifier), name (the project title), and an ownedElements array that nests all subsequent components.[51] Model elements, such as UML classes or packages, are defined with attributes including name, stereotype, type, and their own ownedElements for containment relationships, while views correspond to visual renderings in diagrams.[51] Diagrams are embedded as specialized model elements (e.g., _type: "UMLClassDiagram") containing ownedViews arrays that link view elements to their underlying models, supporting attributes like positions, sizes, and styles for rendering.[51]
This format evolved with the release of StarUML 2.0 in 2014, transitioning from the XML-based .uml files of version 1 to JSON for enhanced extensibility and simplicity in handling complex UML structures.[52][53] The .mdj structure's advantages include its diff-friendly properties, allowing efficient tracking of changes in tools like Git or SVN through textual comparisons.[54]