Welcome to Bigraph Framework

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

• Stable: 2.3.5
• Previous Stable Versions: 2.3.4, 2.3.3, 2.3.2, 2.3.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
2.3.4, 2.3.3, 2.3.2, 2.3.1, 2.3.0	2.0.2
2.3.5	2.0.3

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 Java framework designed for developers and researchers for building, simulating, and analyzing reactive systems (e.g., cyber-physical, context-aware, agent-based, or distributed systems, IoT environments, ...).

It lets you model dynamic systems with both structure (who is inside what) and connectivity (who is connected and interacting to whom), and then simulate, visualize, and verify how those systems evolve over time.

Under the hood, the framework is based on Milner’s theory of Bigraphical Reactive Systems (BRS).

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

Bigraph Modeling and Persistence

• Create and manipulate bigraphs dynamically at design time and runtime using the Bigraph Ecore Metamodel (BEM) (bigraphs.bigraph-ecore-metamodel)
• Load and store both bigraph metamodels and instance models in standard file formats (Ecore/XMI)

Visualization and Inspection

• Export bigraphs and transition systems to standard graph formats: GraphViz (DOT), PNG, VCG (yComp)
• Interactive, programmatic visualization via GraphStream for exploring structures

Bigraphical Reactive Systems (BRS)

Model and analyze system dynamics using reaction rules and graph rewriting:

• Pattern matching and rewriting powered by jLibBig, with full node and link tracking
• Specialized link-graph (hypergraph) matching
• Multiple simulation and model-checking strategies:
  • Breadth-first search (BFS)
  • Depth-first search (DFS)
  • Random exploration
  • Match-all / Match-first
• Automatic construction of Labeled Transition Systems (LTS)
• State predicates and logical connectors for property checking
• Rule priorities to control nondeterminism and execution order
• Tracking rules to preserve identity of entities across reactions
• Conditional rules for guarded rewriting

Import, Export, and Tool Interoperability

• Export bigraphs and LTSs to standard graph formats: DOT, GraphML, GXL, VCG
• Interoperate with other bigraph tools: BigMC, BigraphER, BigRed, jLibBig, and others

Attributed Bigraphs

• Attach arbitrary attributes to:
  • Nodes
  • Links (edges and outer names)
• Attributes are preserved during rewriting, enabling data-rich CPS and agent-based models (via tracking maps)

Use / Install / Dependencies

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.

Usage and Development Requirements:

• Java >=21
• Maven v3.8.7 or Gradle

Quick Start: Project Template

To get started using Bigraph Framework right away, download the Maven/Gradle-based Project Template

• 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.

Project 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.3.5</version>
</dependency>
<!-- Simulation Module -->
<dependency>
  <groupId>org.bigraphs.framework</groupId>
  <artifactId>bigraph-simulation</artifactId>
  <version>2.3.5</version>
</dependency>
<!-- Visualization Module -->
<dependency>
  <groupId>org.bigraphs.framework</groupId>
  <artifactId>bigraph-visualization</artifactId>
  <version>2.3.5</version>
</dependency>
<!-- Converter Module -->
<dependency>
  <groupId>org.bigraphs.framework</groupId>
  <artifactId>bigraph-converter</artifactId>
  <version>2.3.5</version>
</dependency>

Gradle

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

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

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.