clafer: clafer compiles Clafer models to other formats, such as Alloy, XML, HTML, Dot.

[ library, mit, model, program ] [ Propose Tags ]
This version is deprecated.

Clafer is a general purpose, lightweight, structural modeling language developed at GSD Lab, University of Waterloo. Lightweight modeling aims at improving the understanding of the problem domain in the early stages of software development and determining the requirements with fewer defects. Clafer's goal is to make modeling more accessible to a wider range of users and domains. The tool provides a reference language implementation. It translates models to other formats (e.g. Alloy, XML) to allow for reasoning with existing tools.

[Skip to Readme]


Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees


Versions [RSS] 0.3.5,, 0.3.6,, 0.3.7, 0.3.8, 0.3.9, 0.3.10, 0.4.0, 0.4.1, 0.4.2,, 0.4.3, 0.4.4, 0.4.5 (info)
Change log
Dependencies array (>=, base (>= && <5), clafer (==0.3.5), cmdargs (>=0.10.5), containers (>=, data-stringmap (>=0.9.1), directory (>=, executable-path (>=0.0.3), filepath (>=, glpk-hs (>=0.3.4), HaXml (>=1.24), HUnit (>=, json-builder (>=0.3), MaybeT (>=0.1.2), mtl (>=2.1.2), parsec (>=3.1.3), process (>=, QuickCheck (>=, split (>=0.2.2), string-conversions (>=0.3), test-framework (>=0.8), test-framework-hunit (>=0.3.0), test-framework-quickcheck2 (>=, test-framework-th (>=0.2.4), transformers (>= [details]
License MIT
Author Kacper Bak, Jimmy Liang, Michal Antkiewicz, Chris Walker, Luke Michael Brown
Category Model
Home page
Source repo head: git clone git://
Uploaded by mantkiew at 2014-01-30T18:21:40Z
Reverse Dependencies 3 direct, 0 indirect [details]
Executables clafer
Downloads 10790 total (12 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs uploaded by user [build log]
All reported builds failed as of 2015-12-11 [all 1 reports]

Readme for clafer-0.3.5

[back to package description]



Clafer is a general-purpose lightweight structural modeling language developed at GSD Lab, University of Waterloo. Clafer can be used for modeling of static hierarchical structures but has no support for modeling the change of the structures over time (behavior). The main goal of Clafer is to make modeling more accessible to a wider range of users and domains.

There are many possible applications of Clafer; however, three are prominent:

  1. Product-Line Modeling - aims at representing and managing commonality and variability of assets in product lines and creating and verifying product configurations. Clafer naturally supports multi-staged configuration.

  2. Multi-Objective Product Optimization - aims at finding a set of products in a given product line that are optimal with respect to a set of objectives. Clafer multi-objective optimizer generates a Pareto front of optimal product configurations.

  3. Domain Modeling - aims at improving the understanding of the problem domain in the early stages of software development and determining the requirements with fewer defects. This is also known as Concept Modeling or Ontology Modeling.

Clafer Compiler

Clafer compiler provides a reference language implementation. It translates models in Clafer to other formats (e.g. Alloy, XML, HTML, DOT) to allow for reasoning and processing with existing tools.

Currently, the compiler is used by Clafer Instance Generator (ClaferIG), Clafer Integrated Development Environment (ClaferIDE), Clafer Configurator (ClaferConfigurator), Clafer Multi-Objective Optimizer (ClaferMOO) and Visualizer, and Clafer Wiki (ClaferWiki).


  • Kacper Bak, Ph.D. Candidate. Main developer.
  • Jimmy Liang, MSc. Candidate. Main developer.
  • Michał Antkiewicz, Research Engineer. Requirements, development, architecture, testing, technology transfer.
  • Ed Zulkoski, Pd.D. Candidate. Python IR Generator.
  • Luke Michael Brown, co-op student May-Aug 2013. Many improvements.
  • Rafael Olaechea, Pd.D. Candidate. Multi-Objective Optimization extensions.

Getting Clafer Tools

Binary distributions of the release 0.3.5 of Clafer Tools for Windows, Mac, and Linux, can be downloaded from Clafer Tools - Binary Distributions. Clafer Wiki requires Haskell Platform and MinGW to run on Windows.

In case these binaries do not work on your particular machine configuration, the tools can be built from source code, as described below.

Dependencies for running


  1. download the binaries and unpack <target directory> of your choice
  2. add the <target directory> to your system path so that the executables can be found
  3. copy alloy's jars to the <target directory>/tools folder

On Linux

  1. libglpk-dev v4.52
  • execute sudo apt-get install libglpk-dev on Ubuntu
  1. libgmp-dev
  • execute sudo apt-get install libgmp-dev on Ubuntu

On Windows

  1. The binary distribution already includes the GNU Linear Programming Kit DLL glpk_4_52.dll.

On Mac

  1. install GPLK from MacPorts
  • execute sudo port install glpk +universal

Integration with Sublime Text 2

See IDEs/

Installation From Hackage


Clafer is now available on Hackage and it can be installed using

  • cabal update
  • cabal install clafer
  • To automatically download Alloy jars, execute make in clafer-0.3.5/tools inside the Cabal's library folder

You'll still need to install GLPK 4.52 for your operating system as described below.

Building & Installation From Source Code

Additional dependencies for building

On Linux

  • libglpk-dev v4.52
    • sudo apt-get install libglpk-dev on Ubuntu

On Windows

  • MinGW+MSYS
    • since the Haskell Platform already contains MinGW, you may choose to install MinGW+MSYS to the same location, e.g., c:\...\Haskell Platform\2013.2.0.0
    • add the bin folders of MinGW (MinGW\bin) and MSYS (MinGW\MSYS\1.0\bin) to your system path
    • wget will be automatically installed
  • WinGLPK v4.52
    • inside the w32 folder, copy glpk_4_52.dll toglpk.dll so that it can be found when building Haskell package glpk-hs
    • from w32 folder, copy glpk_4_52.dll to <user>\AppData\Roaming\cabal\bin

On Mac only

  1. install GPLK 4.52 from MacPorts
  2. execute sudo port install glpk +universal

Important: Branches must correspond

All related projects are following the simultaneous release model. The branch master contains releases, whereas the branch develop contains code under development. When building the tools, the branches should match. Releases from branches 'masterare guaranteed to work well together. Development versions from branchesdevelop` should work well together but this might not always be the case.


  1. install the dependencies
  2. open the command line terminal. On Windows, open MinGW.
  3. in some <source directory> of your choice, execute
  • git clone git://
  1. in <source directory>/clafer, execute
  • cabal update
  1. On Linux and Mac execute
  • make
  1. On Windows (in MinGW), execute
  • make glpk="/c/<your WinGLPK install dir>"


  1. On Linux and Mac execute
  • make install to=<target directory>
  1. On Windows (in MinGW), execute
  • make glpk="/c/<your WinGLPK instal dir>" to=/c/<target directory>
  1. add the <target directory> to your system PATH

On Windows only

  • copy GLPK's dll glpk-0.4.52.dll to the <target directory> folder or any other folder on the system path


On Windows, use / with the make command instead of \.


Clafer Compiler

(As printed by clafer --help)

Clafer v0.3.5.20-01-2014

clafer [OPTIONS] [FILE]

Common flags:
  -m --mode=CLAFERMODE                    Generated output type. Available
                                          CLAFERMODEs are: 'alloy' (default,
                                          Alloy 4.1); 'alloy42' (Alloy 4.2);
                                          'xml' (intermediate representation of
                                          Clafer model); 'clafer' (analyzed and
                                          desugared clafer model); 'html'
                                          (original model in HTML); 'graph'
                                          (graphical representation written in
                                          DOT language); 'cvlgraph' (cvl
                                          notation representation written in
                                          DOT language); 'python' (generates IR
                                          in python); 'choco' (Choco constraint
                                          programming solver). Multiple modes
                                          can be specified at the same time,
                                          e.g., '-m alloy -m html'.
  -o --console-output                     Output code on console.
  -i --flatten-inheritance                Flatten inheritance ('alloy' and
                                          'alloy42' modes only).
     --timeout-analysis=INT               Timeout for analysis.
  -l --no-layout                          Don't resolve off-side rule layout.
     --nl --new-layout                    Use new fast layout resolver
  -c --check-duplicates                   Check duplicated clafer names.
  -f --skip-resolver                      Skip name resolution.
  -k --keep-unused                        Keep uninstantated abstract clafers
                                          ('alloy' and 'alloy42' modes only).
  -s --no-stats                           Don't print statistics.
     --schema                             Show Clafer IR (intermediate
                                          representation) XML schema.
  -v --validate                           Validate outputs of all modes. Uses
                                          'tools/XsdCheck.class' for XML,
                                          'tools/alloy4.jar' and
                                          'tools/alloy4.2.jar' for Alloy
                                          models, and Clafer translator for
                                          desugared Clafer models. Use
                                          '--tooldir' to override the default
                                          location of these tools.
     --nr --noalloyruncommand             For usage with partial instances:
                                          Don't generate the alloy 'run show
                                          for ... ' command, and rename @.ref
                                          with unique names  ('alloy' and
                                          'alloy42' modes only).
     --tooldir=DIR                        Specify the tools directory
                                          ('validate' only). Default: 'tools/'.
  -a --alloy-mapping                      Generate mapping to Alloy source
                                          code ('alloy' and 'alloy42' modes
     --self-contained                     Generate a self-contained html
                                          document ('html' mode only).
     --add-graph                          Add a graph to the generated html
                                          model ('html' mode only). Requires
                                          the "dot" executable to be on the
                                          system path.
     --sr --show-references               Whether the links for references
                                          should be rendered. ('html' and
                                          'graph' modes only).
     --add-comments                       Include comments from the source
                                          file in the html output ('html' mode
  -e --ecore2clafer                       Translate an ECore model into
     --ss=SCOPESTRATEGY --scope-strategy  Use scope computation strategy:
                                          none, simple (default), or full.
     --check-afm --afm                    Throws an error if the cardinality
                                          of any of the clafers is above 1.
     --sg --skip-goals                    Skip generation of Alloy code for
                                          goals. Useful for all tools working
                                          with standard Alloy.
     --meta-data                          Generate a 'fully qualified
                                          name'-'unique ID' map ('.cfr-map').
                                          In Alloy, Alloy42, and Choco modes,
                                          generate the scopes map
  -? --help                               Display help message
  -V --version                            Print version information

The dependencies among the command line arguments are described on the model wiki.

Additionally, [OPTIONS] can also be specified directly in the model file by inserting the following compiler directive as the first line of the file:


for example

//# --keep-unused -m=alloy42

Options given at command line override the options given in the file using //# which, in turn, override the defaults.

Using compiler directives

Compiler directives are comments of the form

//# <directive name>

The following directives are markers of locations in the input files for different purposes:

  • //# FRAGMENT - marks the beginning of the new module fragment.
  • //# GRAPH - marks the insertion point for a graph rendering. The graph is only produced in HTML mode with the argument --add-graph.
  • //# STATS - marks the insertion point for module statistics. The statistics can be omitted using the argument --no-stats.
  • //# SUMMARY - shorthand for //# GRAPH and //# STATS
  • //# QUALITY_ATTRIBUTE - is used by ClaferMooVisualizer and ClaferConfigurator to distinguish quality attributes, which should be filtered out, from other clafers.

Need help?