Welcome to Bigraph Framework

This manual provides a complete guide to the Bigraph Framework.
Last Updated: 2025-09-27

• Stable: 2.2.1
• Previous Stable Versions: 2.2.0, 2.1.2, 2.1.1

Migration 2.1.2 → 2.2.0

For refactor and upgrade instructions, please see the GitHub Releases Changelog.

Version Compatibility

This table specifies the metamodel standards supported by the Bigraph Framework.

Bigraph Framework	Bigraph Ecore Metamodel
1.0.0	1.6.0
1.1.0	1.6.1
2.2.1, 2.2.0, 2.1.2, 2.1.1, 2.1.0, 2.0.2, 2.0.1	2.0.1, 1.6.1

Caution

Since version 1.0.0 of Bigraph Framework: The new groupID and base package name org.bigraphs.* is used instead of the former one de.tudresden.inf.st.bigraphs.*.

What is Bigraph Framework?

Bigraph Framework is a software framework written in Java for the creation and simulation of bigraphs and bigraphical reactive systems to expedite the experimental evaluation of the bigraph theory in real-world applications.

The goal of this framework is to facilitate the implementation of reactive systems, including context-aware, agent-based systems or cyber-physical systems. The high level API eases the programming of bigraphical systems for various applications. The framework is developed around a metamodel-first approach, when working with bigraphical structures.

Features

• Modelling and Storage
  • Dynamic creation of bigraphs at design time and runtime based on the Bigraph Ecore Metamodel (BEM)
  • Read and write instance models and metamodels of a bigraph from and to the file system
• Visualization
  • Graphical export via GraphViz/DOT, PNG, Visualization of Compiler Graphs (VCG) format via yComp
  • Interactive visualization via GraphStream
• Bigraphical Reactive Systems (BRS): Simulate the evolution of bigraphs by reaction rules
  • Bigraph matching and rewriting via jLibBig
  • Generation of a labeled transition system (LTS)
  • Simulation and Model Checking (BFS, Random)
  • Predicate checking
  • Specify order of reaction rules via priorities
  • Tracking rules (trace node identities across reactions)
  • Conditional rules (not yet integrated in model checking procedure but available for custom usage)
• Model Importer/Exporter
  • Export a bigraph to common graph formats, e.g., DOT, GraphML, GXL, VCG
  • Export to formats of other bigraph tools: BigMC, BigraphER, BigRed, jLibBig, ...
• Attributed Bigraphs
  • Add arbitrary attributes to nodes
  • Attributes are preserved when doing rewriting (this requires tracking maps)

What are Bigraphs?

Bigraphs are an emerging theory and metamodel for global ubiquitous systems, mobile computing, context-aware systems and the Internet of Things (IoT), or in general: for reactive systems. It is grounded on category theory and regarded as a unifying framework for many process calculi, including the ambient calculus, action calculi, Petri nets, the Calculus of Communicating Systems (CCS) and π-calculus. The theory provides an algebra and a graph rewriting mechanism to describe, study and analyze the dynamic behavior of reactive systems.

Usage and Development Requirements

• Java >=17
• Maven v3.8.3 or Gradle

Use / Install / Dependency Settings

Bigraph Framework is online available as Maven/Gradle dependency.

Artifacts are deployed to the Central Repository.

Building from Source

To build the source by yourself, follow the README.md inside the code repository.

Quick Start: Starter Project Template

To get started using Bigraph Framework right away, download the Maven-based Project Skeleton

• Starter Project Template using Bigraph Framework
• See here for the latest version on GitHub

The README contained therein, describes how to compile and start an application.

Alternatively, follow the step-by-step project setup as described in the following.

Package Dependencies

Depending on the build management tool you are using, one of the following configuration for Maven or Gradle is necessary.

Maven

Add this inside the dependencies section of your project's *.pom file. Replace VERSION with the latest version.

<!-- Core Module -->
<dependency>
  <groupId>org.bigraphs.framework</groupId>
  <artifactId>bigraph-core</artifactId>
  <version>2.2.1</version>
</dependency>
<!-- Simulation Module -->
<dependency>
  <groupId>org.bigraphs.framework</groupId>
  <artifactId>bigraph-simulation</artifactId>
  <version>2.2.1</version>
</dependency>
<!-- Visualization Module -->
<dependency>
  <groupId>org.bigraphs.framework</groupId>
  <artifactId>bigraph-visualization</artifactId>
  <version>2.2.1</version>
</dependency>
<!-- Converter Module -->
<dependency>
  <groupId>org.bigraphs.framework</groupId>
  <artifactId>bigraph-converter</artifactId>
  <version>2.2.1</version>
</dependency>

Gradle

Append this in your build.gradle file. Replace VERSION with the latest version.

compile "org.bigraphs.framework:bigraph-core:2.2.1"
compile "org.bigraphs.framework:bigraph-simulation:2.2.1"
compile "org.bigraphs.framework:bigraph-visualization:2.2.1"
compile "org.bigraphs.framework:bigraph-converter:2.2.1"

Manually

Manual setup is not recommended. Refer to the README.md in Bigraph Framework's code repository on how to build the framework from source.

Logging Configuration

Bigraph Framework employs SLF4J as a facade for the log4j logging framework.

Depending on your project setup, you may need to include the following libraries in your pom.xml:

<dependencies>
    <!-- For any Maven project in general -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>2.0.9</version>
    </dependency>
    <!-- Use a no-operation (NOP) logger implementation -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-nop</artifactId>
        <version>2.0.7</version>
    </dependency>
    <!-- or, for example, the reload4j implementation (fork of log4j) -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-reload4j</artifactId>
        <version>2.0.9</version>
    </dependency>

    <!-- When used within a Spring project -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-logging</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-log4j2</artifactId>
    </dependency>
</dependencies>

Not including these dependencies will result in warnings. The example above shows how to use a NOP logger or a reload4j as the underlying logging framework in your project.