ArgoUML is a modelling tool that helps you do your design using UML.

Install with Java Web Start

The ArgoUML website provides easy installation with Java Web Start.

Runs on any platform with Java1.4 or Java5

ArgoUML is written entirely in Java and uses the Java Foundation Classes. This allows ArgoUML to run on virtually any platform.

Standard UML Meta-Model

ArgoUML is compliant with the OMG Standard for UML 1.3. The code for the internal representation of an UML model is completely generated from the specification and, thus, follows it very closely. To achieve this, a special meta-model library (NSUML) was developed by Novosoft and made available under LGPL.

UML Diagram Support

ArgoUML uses GEF, the UCI Graph Editing Framework to edit UML diagrams. The following diagram types are supported:

  • Class diagram
  • Statechart diagram
  • Activity diagram
  • Use Case diagram
  • Collaboration diagram
  • Deployment diagram (includes Object and Component diagram in one)
  • Sequence diagram (not working in version 0.12, not available in version 0.14, 0.16 or 0.18, will be available in 0.20)

XMI Support

XMI is an XML based exchange format between UML tools. ArgoUML uses this as standard saving mechanism so that easy interchange with other tools and compliance with open standards are secured. XMI version 1.0 for UML 1.3 is used. To convert older models in XMI (Argo 0.7 used XMI 1.0 for UML1.1) to the latest version, Meta Integration provides a free key to their Model Bridge. This also permits you to convert Rational Rose models to ArgoUML! This currently only includes model information, but no graphical information (like layout of diagrams).

Several diagram export formats

Diagrams can be saved as GIF, PostScript, Encapsulated PS, PGML and SVG.


ArgoUML has been internationalized to American English, British English, French, German, Spanish and Russian. Norwegian Bokmål and Chinese are underway. Portuguese and Catalan are considered.

Diagram Editing

ArgoUML supports many diagram editing features that help you edit UML diagrams.

OCL Support

ArgoUML provides constraint modeling support on UML Classes and Features. The Dresden OCL toolkit enables ArgoUML to perform syntax and type checking on those constraints. OCL support has been provided by and developed at the Technical University of Dresden, thanks!

Code Generation

ArgoUML provides a modular code generation framework. Currently Java is provided by default and there are modules for C++, C# and PHP. The Java code generation works with the Java reverse engineering to provide basic round - trip.

Reverse Engineering

ArgoUML provides a modular reverse engineering framework. Currently Java source code is provided by default and there are modules for Java Jar and class file import.

Design Critics

Design critics are simple agents that continuously execute in a background thread of control. They analyze the design as the designer is working and suggest possible improvements. These suggestions range from indications of syntax errors, to reminders to return to parts of the design that need finishing, to style guidelines, to the advice of expert designers. Many critics offer to automatically improve the design. Critics are controlled so that their suggestions are relevant and timely to the design task at hand, based on information in Argo's user model. Critics never interrupt the designer, instead they post their suggestions to the designer's "to do" list.

Corrective Automations (partially implemented)

Critics identify specific problems in the design and may offer specific solutions in the form of wizards or other corrective automations. These automations allow design improvements to be made faster and more reliably than they could be done by hand. Also, designers need not recall how to use the tool to achieve the suggested change.

"To Do" List

One difficulty designers face is keeping track of the myriad of details of their task. It is all to easy to skip a step in the design process, leave part of the design unspecified, of make a mistake that requires revision. Argo provides the designer with a "to do" list user interface that presents action items in an organized form. These items can be suggestions from critics, reminders to finish steps in the process model, or personal notes entered by the designer. The choice control at the top of the "to do" list pane allow the designer to organize items in different ways: by priority, by decision supported, by offending design element, etc. Items are shown under all applicable headings. The "to do" list may also be viewed as a flat list.

User Model (partially implemented)

Argo's user model maintains information about the designer and uses that information to make the tool my useful. One way that it does this is by controlling critics so that only critics that are timely and relevant to the task at hand can make suggestions. In the future, the corrective automations and explanations offered by critics will also be tailored to the designer.

Argo's user model consists of the following parts:

  • Decision Model: Lists types of decisions that must be made when doing object oriented design. Each decision is associated with an level of interest from 0 to 5. A critic will not be active if the designer's interest in the decision that it supports is 0.
  • Goals Model (partially implemented): Presents a list of questions related to goals for the design project. Critics that support active goals may present suggestions.
  • Work Breakdown Structure (future): Lists the tasks that must be performed when doing object oriented design. Each task is associated with a level of activity and several decisions. This model serves the designer as a resource when deciding what task to do next.
  • Skill Model (future): Each designer has their own strengths and weaknesses. Argo's skill model keeps track of the designer's self-reported level of knowledge related to the problem and solution domains. The estimated time to fix a problem found by a critic depends on the designer's knowledge of domain concepts, design techniques, and tool features.


Checklists are currently widely used in design review meetings, in part, because they remind designers to cover all design details and avoid common design errors. Argo provides checklists that serve the same purpose, but have several advantages over passive printed lists:

  • Argo's checklists are made specific to the selected design element. Each type of design element (e.g., Class, Attribute, Operation, Association) has its own checklist.
  • Irrelevant checklist items are automatically removed from the list.
  • The text of the checklist items are made specific to the design element being reviewed. For example, Argo uses element names instead of the pronouns that would be used in a printed list.
  • (future) Checklist items can provide the designer with wizards that help complete a specified design change. For example, the checklist item "Should the attribute Age be moved to one of the super classes of Person (e.g., Animal)" could launch a wizard to help move the attribute up the class hierarchy.

Checklists are somewhat similar to critics (in fact, they share some of the same implementation), however they differ in the level of specificity so much that we feel that they should be presented separately to designers. Critics look for very specific problems and provide specific suggestions when those problems are detected. The designer still makes the final decision about any design changes, but the critic can automate much of the analysis and work. In contrast, checklist items are much more general and vague, they serve to remind the designer, but it is the designer who must do most of the analysis and work.

Explorer Perspectives

Argo, like most tools, provides a tree view to allow the designer to access the various parts of their modeling project. Unlike other tools, Argo provides the designer with a much richer set of alternative tree views of the project.

Multiple, Overlapping Views

Complex designs are made up of hundreds of elements with complex relationships to each other. Designers are better able to understand the design and make changes when they can see the elements and relationships that affect a certain design issue. No single diagram can clarify all design issues. Instead multiple diagrams and other presentations must be used.

Argo allows multiple graphical representations of the same design element to be used in different diagrams. In this sense, the views are overlapping.

ArgoUML has 4 main views: Explorer, Diagram, Details, Critics.

Alternative Design Representations: Graphs, Text, or Table

Diagrams are the main way of presenting object-oriented designs. Argo can also provide tabular presentations of the design and textual presentations in the form of source code, and (future) English language explanations. Argo allows (future) editing in any of these presentations, and all of them are kept consistent.

Licence: BSD License