152 files changed, 9131 insertions, 1344 deletions

diff --git a/settings.gradle.kts b/settings.gradle.kts
index d0f82de8..075faa7c 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -14,6 +14,7 @@ include(
                 "language-semantics",
                 "language-web",
                 "store",
+                "store-dse",
                 "store-query",
                 "store-query-viatra",
                 "store-reasoning",
@@ -22,6 +23,7 @@ include(
                 "viatra-runtime-localsearch",
                 "viatra-runtime-rete",
                 "viatra-runtime-rete-recipes",
+                "visualization",
 )
 
 for (project in rootProject.children) {
diff --git a/subprojects/store-dse/build.gradle.kts b/subprojects/store-dse/build.gradle.kts
new file mode 100644
index 00000000..5734fa09
--- /dev/null
+++ b/subprojects/store-dse/build.gradle.kts
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+plugins {
+        id("tools.refinery.gradle.java-library")
+}
+
+dependencies {
+        api(project(":refinery-store-query"))
+        implementation(libs.eclipseCollections.api)
+        runtimeOnly(libs.eclipseCollections)
+        testImplementation(project(":refinery-store-query-viatra"))
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/ActionFactory.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/ActionFactory.java
new file mode 100644
index 00000000..48a508b4
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/ActionFactory.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.function.Consumer;
+
+public interface ActionFactory {
+        Consumer<Tuple> prepare(Model model);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/ModificationAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/ModificationAdapter.java
new file mode 100644
index 00000000..f15c16e0
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/ModificationAdapter.java
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.modification;
+
+import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.dse.modification.internal.ModificationBuilderImpl;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple1;
+
+public interface ModificationAdapter extends ModelAdapter {
+
+        int getModelSize();
+
+        Tuple1 createObject();
+
+        Tuple deleteObject(Tuple tuple);
+
+        static ModificationBuilder builder() {
+                return new ModificationBuilderImpl();
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/ModificationBuilder.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/ModificationBuilder.java
new file mode 100644
index 00000000..48c22bdf
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/ModificationBuilder.java
@@ -0,0 +1,11 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.modification;
+
+import tools.refinery.store.adapter.ModelAdapterBuilder;
+
+public interface ModificationBuilder extends ModelAdapterBuilder {
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/ModificationStoreAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/ModificationStoreAdapter.java
new file mode 100644
index 00000000..144c4d05
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/ModificationStoreAdapter.java
@@ -0,0 +1,11 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.modification;
+
+import tools.refinery.store.adapter.ModelStoreAdapter;
+
+public interface ModificationStoreAdapter extends ModelStoreAdapter {
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/internal/ModificationAdapterImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/internal/ModificationAdapterImpl.java
new file mode 100644
index 00000000..b2a80d71
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/internal/ModificationAdapterImpl.java
@@ -0,0 +1,62 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.modification.internal;
+
+import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.store.dse.modification.ModificationAdapter;
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple1;
+
+public class ModificationAdapterImpl implements ModificationAdapter {
+        static final Symbol<Integer> NEXT_ID = Symbol.of("NEXT_ID", 0, Integer.class, 0);
+
+        final ModelStoreAdapter storeAdapter;
+        final Model model;
+        Interpretation<Integer> nodeCountInterpretation;
+
+        ModificationAdapterImpl(ModelStoreAdapter storeAdapter, Model model) {
+                this.storeAdapter = storeAdapter;
+                this.model = model;
+                this.nodeCountInterpretation = model.getInterpretation(NEXT_ID);
+        }
+
+        @Override
+        public Model getModel() {
+                return model;
+        }
+
+        @Override
+        public ModelStoreAdapter getStoreAdapter() {
+                return storeAdapter;
+        }
+
+        @Override
+        public int getModelSize() {
+                return nodeCountInterpretation.get(Tuple.of());
+        }
+
+        @Override
+        public Tuple1 createObject() {
+                var newNodeId = getModelSize();
+                nodeCountInterpretation.put(Tuple.of(), newNodeId + 1);
+                return Tuple.of(newNodeId);
+        }
+
+        @Override
+        public Tuple deleteObject(Tuple tuple) {
+                if (tuple.getSize() != 1) {
+                        throw new IllegalArgumentException("Tuple size must be 1");
+                }
+//              TODO: implement more efficient deletion
+                if (tuple.get(0) == getModelSize() - 1) {
+                        nodeCountInterpretation.put(Tuple.of(), getModelSize() - 1);
+                }
+                return tuple;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/internal/ModificationBuilderImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/internal/ModificationBuilderImpl.java
new file mode 100644
index 00000000..c4d38d22
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/internal/ModificationBuilderImpl.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.modification.internal;
+
+import tools.refinery.store.adapter.AbstractModelAdapterBuilder;
+import tools.refinery.store.dse.modification.ModificationBuilder;
+import tools.refinery.store.dse.modification.ModificationStoreAdapter;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.statecoding.StateCoderBuilder;
+
+public class ModificationBuilderImpl extends AbstractModelAdapterBuilder<ModificationStoreAdapter> implements ModificationBuilder {
+
+        @Override
+        protected void doConfigure(ModelStoreBuilder storeBuilder) {
+                storeBuilder.symbols(ModificationAdapterImpl.NEXT_ID);
+                storeBuilder.tryGetAdapter(StateCoderBuilder.class).ifPresent(
+                                coderBuilder -> coderBuilder.exclude(ModificationAdapterImpl.NEXT_ID));
+                super.doConfigure(storeBuilder);
+        }
+
+        @Override
+        protected ModificationStoreAdapter doBuild(ModelStore store) {
+                return new ModificationStoreAdapterImpl(store);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/internal/ModificationStoreAdapterImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/internal/ModificationStoreAdapterImpl.java
new file mode 100644
index 00000000..913cb33f
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/internal/ModificationStoreAdapterImpl.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.modification.internal;
+
+import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.dse.modification.ModificationStoreAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+
+public class ModificationStoreAdapterImpl implements ModificationStoreAdapter {
+        ModelStore store;
+
+        ModificationStoreAdapterImpl(ModelStore store) {
+                this.store = store;
+        }
+
+        @Override
+        public ModelStore getStore() {
+                return store;
+        }
+
+        @Override
+        public ModelAdapter createModelAdapter(Model model) {
+                return null;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstExplorer.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstExplorer.java
new file mode 100644
index 00000000..72bbbc55
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstExplorer.java
@@ -0,0 +1,164 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.strategy;
+
+import tools.refinery.store.dse.transition.ObjectiveValue;
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.model.Model;
+
+import java.util.Random;
+
+public class BestFirstExplorer extends BestFirstWorker {
+        final int id;
+        Random random;
+        public BestFirstExplorer(BestFirstStoreManager storeManager, Model model, int id) {
+                super(storeManager, model);
+                this.id = id;
+                this.random = new Random(id);
+        }
+
+        private boolean interrupted = false;
+        public void interrupt() {
+                this.interrupted = true;
+        }
+
+        private boolean shouldRun() {
+                return !interrupted && !hasEnoughSolution();
+        }
+
+        public void explore() {
+                VersionWithObjectiveValue lastVisited = submit().newVersion();
+
+                mainLoop: while (shouldRun()) {
+
+                        if (lastVisited == null) {
+                                var restored = this.restoreToBest();
+                                if(restored != null) {
+                                        lastVisited = restored;
+                                } else {
+                                        return;
+                                }
+                        }
+
+                        boolean tryActivation = true;
+                        while(tryActivation && shouldRun()) {
+                                RandomVisitResult randomVisitResult = this.visitRandomUnvisited(random);
+
+                                tryActivation &= randomVisitResult.shouldRetry();
+                                var newSubmit = randomVisitResult.submitResult();
+                                if(newSubmit != null) {
+                                        if(!newSubmit.include()) {
+                                                restoreToLast();
+                                        } else {
+                                                var newVisit = newSubmit.newVersion();
+                                                int compareResult = compare(lastVisited,newVisit);
+                                                if(compareResult >= 0) {
+                                                        lastVisited = newVisit;
+                                                        continue mainLoop;
+                                                }
+                                        }
+                                }
+                        }
+
+                //final ObjectiveComparatorHelper objectiveComparatorHelper = dseAdapter.getObjectiveComparatorHelper();
+
+                /*boolean globalConstraintsAreSatisfied = dseAdapter.checkGlobalConstraints();
+                if (!globalConstraintsAreSatisfied) {
+                        // Global constraint is not satisfied in the first state. Terminate.
+                        return;
+                }
+
+                final Fitness firstFitness = dseAdapter.getFitness();
+                if (firstFitness.isSatisfiesHardObjectives()) {
+                        dseAdapter.newSolution();
+                        // First state is a solution. Terminate.
+                        if (backTrackIfSolution) {
+                                return;
+                        }
+                }
+
+                if (maxDepth == 0) {
+                        return;
+                }*/
+
+                /*
+                var firstTrajectoryWithFitness = new TrajectoryWithFitness(dseAdapter.getTrajectory(), firstFitness);
+                trajectoriesToExplore.add(firstTrajectoryWithFitness);
+                TrajectoryWithFitness currentTrajectoryWithFitness = null;
+                */
+/*
+                        Collection<Activation> activations = dseAdapter.getUntraversedActivations();
+                        Iterator<Activation> iterator = activations.iterator();
+
+                        while (iterator.hasNext()) {
+                                final Activation nextActivation = iterator.next();
+                                if (!iterator.hasNext()) {
+                                        // Last untraversed activation of the state.
+                                        trajectoriesToExplore.remove(currentTrajectoryWithFitness);
+                                }
+
+                                // Executing new activation
+                                dseAdapter.fireActivation(nextActivation);
+                                if (dseAdapter.isCurrentStateAlreadyTraversed()) {
+                                        // The new state is already visited.
+                                        dseAdapter.backtrack();
+                                } else if (!dseAdapter.checkGlobalConstraints()) {
+                                        // Global constraint is not satisfied.
+                                        dseAdapter.backtrack();
+                                } else {
+                                        final Fitness nextFitness = dseAdapter.getFitness();
+                                        if (nextFitness.isSatisfiesHardObjectives()) {
+                                                dseAdapter.newSolution();
+                                                var solutions = dseAdapter.getSolutions().size();
+                                                if (solutions >= maxSolutions) {
+                                                        return;
+                                                }
+                                                // Found a solution.
+                                                if (backTrackIfSolution) {
+                                                        dseAdapter.backtrack();
+                                                        continue;
+                                                }
+                                        }
+                                        if (dseAdapter.getDepth() >= maxDepth) {
+                                                // Reached max depth.
+                                                dseAdapter.backtrack();
+                                                continue;
+                                        }
+
+                                        TrajectoryWithFitness nextTrajectoryWithFitness = new TrajectoryWithFitness(
+                                                        dseAdapter.getTrajectory(), nextFitness);
+                                        trajectoriesToExplore.add(nextTrajectoryWithFitness);
+
+                                        int compare = objectiveComparatorHelper.compare(currentTrajectoryWithFitness.fitness,
+                                                        nextTrajectoryWithFitness.fitness);
+                                        if (compare < 0) {
+                                                // Better fitness, moving on
+                                                currentTrajectoryWithFitness = nextTrajectoryWithFitness;
+                                                continue mainLoop;
+                                        } else if (compare == 0) {
+                                                if (onlyBetterFirst) {
+                                                        // Equally good fitness, backtrack
+                                                        dseAdapter.backtrack();
+                                                } else {
+                                                        // Equally good fitness, moving on
+                                                        currentTrajectoryWithFitness = nextTrajectoryWithFitness;
+                                                        continue mainLoop;
+                                                }
+                                        } else {
+                                                //"Worse fitness
+                                                currentTrajectoryWithFitness = null;
+                                                continue mainLoop;
+                                        }
+                                }
+                        }
+
+                        // State is fully traversed.
+                        currentTrajectoryWithFitness = null;
+*/
+                }
+                // Interrupted.
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStoreManager.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStoreManager.java
new file mode 100644
index 00000000..693b0903
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStoreManager.java
@@ -0,0 +1,72 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.strategy;
+
+import tools.refinery.store.dse.transition.DesignSpaceExplorationStoreAdapter;
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.dse.transition.statespace.ActivationStore;
+import tools.refinery.store.dse.transition.statespace.EquivalenceClassStore;
+import tools.refinery.store.dse.transition.statespace.ObjectivePriorityQueue;
+import tools.refinery.store.dse.transition.statespace.SolutionStore;
+import tools.refinery.store.dse.transition.statespace.internal.ActivationStoreImpl;
+import tools.refinery.store.dse.transition.statespace.internal.FastEquivalenceClassStore;
+import tools.refinery.store.dse.transition.statespace.internal.ObjectivePriorityQueueImpl;
+import tools.refinery.store.dse.transition.statespace.internal.SolutionStoreImpl;
+import tools.refinery.store.map.Version;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.statecoding.StateCoderStoreAdapter;
+
+import java.util.function.Consumer;
+
+public class BestFirstStoreManager {
+        ModelStore modelStore;
+        ObjectivePriorityQueue objectiveStore;
+        ActivationStore activationStore;
+        SolutionStore solutionStore;
+        EquivalenceClassStore equivalenceClassStore;
+
+        public BestFirstStoreManager(ModelStore modelStore) {
+                this.modelStore = modelStore;
+                DesignSpaceExplorationStoreAdapter storeAdapter =
+                                modelStore.getAdapter(DesignSpaceExplorationStoreAdapter.class);
+
+                objectiveStore = new ObjectivePriorityQueueImpl(storeAdapter.getObjectives());
+                Consumer<VersionWithObjectiveValue> whenAllActivationsVisited = x -> objectiveStore.remove(x);
+                activationStore = new ActivationStoreImpl(storeAdapter.getTransformations().size(), whenAllActivationsVisited);
+                solutionStore = new SolutionStoreImpl(1);
+                equivalenceClassStore = new FastEquivalenceClassStore(modelStore.getAdapter(StateCoderStoreAdapter.class)) {
+                        @Override
+                        protected void delegate(VersionWithObjectiveValue version, int[] emptyActivations, boolean accept) {
+                                objectiveStore.submit(version);
+                                activationStore.markNewAsVisited(version, emptyActivations);
+                                if(accept) {
+                                        solutionStore.submit(version);
+                                }
+                        }
+                };
+        }
+
+        ObjectivePriorityQueue getObjectiveStore() {
+                return objectiveStore;
+        }
+
+        ActivationStore getActivationStore() {
+                return activationStore;
+        }
+
+        SolutionStore getSolutionStore() {
+                return solutionStore;
+        }
+
+        EquivalenceClassStore getEquivalenceClassStore() {
+                return equivalenceClassStore;
+        }
+
+        public void startExploration(Version initial) {
+                BestFirstExplorer bestFirstExplorer = new BestFirstExplorer(this, modelStore.createModelForState(initial), 1);
+                bestFirstExplorer.explore();
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstWorker.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstWorker.java
new file mode 100644
index 00000000..ea7fe43f
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstWorker.java
@@ -0,0 +1,113 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.strategy;
+
+import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
+import tools.refinery.store.dse.transition.ObjectiveValue;
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.dse.transition.statespace.internal.ActivationStoreWorker;
+import tools.refinery.store.map.Version;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.statecoding.StateCoderAdapter;
+
+
+import java.util.Random;
+
+public class BestFirstWorker {
+        final BestFirstStoreManager storeManager;
+        final Model model;
+        final ActivationStoreWorker activationStoreWorker;
+        final StateCoderAdapter stateCoderAdapter;
+        final DesignSpaceExplorationAdapter explorationAdapter;
+
+        public BestFirstWorker(BestFirstStoreManager storeManager, Model model) {
+                this.storeManager = storeManager;
+                this.model = model;
+
+                explorationAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                stateCoderAdapter = model.getAdapter(StateCoderAdapter.class);
+                activationStoreWorker = new ActivationStoreWorker(storeManager.getActivationStore(),
+                                explorationAdapter.getTransformations());
+        }
+
+        private VersionWithObjectiveValue last = null;
+
+        //public boolean isIncluded
+
+        public SubmitResult submit() {
+                if (explorationAdapter.checkExclude()) {
+                        last = null;
+                        return new SubmitResult(false, false, null, null);
+                }
+
+                Version version = model.commit();
+                ObjectiveValue objectiveValue = explorationAdapter.getObjectiveValue();
+                var res = new VersionWithObjectiveValue(version, objectiveValue);
+                var code = stateCoderAdapter.calculateStateCode();
+                var accepted = explorationAdapter.checkAccept();
+
+                boolean isNew = storeManager.getEquivalenceClassStore().submit(res, code,
+                                activationStoreWorker.calculateEmptyActivationSize(), accepted);
+
+                last = new VersionWithObjectiveValue(version, objectiveValue);
+                return new SubmitResult(isNew, accepted, objectiveValue, last);
+        }
+
+        public void restoreToLast() {
+                if (explorationAdapter.getModel().hasUncommittedChanges()) {
+                        explorationAdapter.getModel().restore(last.version());
+                }
+        }
+
+        public VersionWithObjectiveValue restoreToBest() {
+                var bestVersion = storeManager.getObjectiveStore().getBest();
+                if (bestVersion != null) {
+                        this.model.restore(bestVersion.version());
+                }
+                return bestVersion;
+        }
+
+        public VersionWithObjectiveValue restoreToRandom(Random random) {
+                var randomVersion = storeManager.getObjectiveStore().getRandom(random);
+                last = randomVersion;
+                if (randomVersion != null) {
+                        this.model.restore(randomVersion.version());
+                }
+                return randomVersion;
+        }
+
+        public int compare(VersionWithObjectiveValue s1, VersionWithObjectiveValue s2) {
+                return storeManager.getObjectiveStore().getComparator().compare(s1, s2);
+        }
+
+        public boolean stateHasUnvisited() {
+                if (!model.hasUncommittedChanges()) {
+                        return storeManager.getActivationStore().hasUnmarkedActivation(last);
+                } else {
+                        throw new IllegalStateException("The model has uncommitted changes!");
+                }
+        }
+
+        record RandomVisitResult(SubmitResult submitResult, boolean shouldRetry) {
+        }
+
+        public RandomVisitResult visitRandomUnvisited(Random random) {
+                if (!model.hasUncommittedChanges()) {
+                        var visitResult = activationStoreWorker.fireRandomActivation(this.last, random);
+                        if (visitResult.successfulVisit()) {
+                                return new RandomVisitResult(submit(), visitResult.mayHaveMore());
+                        } else {
+                                return new RandomVisitResult(null, visitResult.mayHaveMore());
+                        }
+                } else {
+                        throw new IllegalStateException("The model has uncommitted changes!");
+                }
+        }
+
+        public boolean hasEnoughSolution() {
+                return storeManager.solutionStore.hasEnoughSolution();
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/SubmitResult.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/SubmitResult.java
new file mode 100644
index 00000000..37d548d7
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/SubmitResult.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.strategy;
+
+import tools.refinery.store.dse.transition.ObjectiveValue;
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.map.Version;
+
+public record SubmitResult(boolean include, boolean accepted, ObjectiveValue objective, VersionWithObjectiveValue newVersion) {
+
+        }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationAdapter.java
new file mode 100644
index 00000000..37448309
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationAdapter.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition;
+
+import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.dse.transition.internal.DesignSpaceExplorationBuilderImpl;
+import tools.refinery.store.map.Version;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple1;
+
+import java.util.Collection;
+import java.util.List;
+
+public interface DesignSpaceExplorationAdapter extends ModelAdapter {
+
+
+
+        @Override
+        DesignSpaceExplorationStoreAdapter getStoreAdapter();
+
+        static DesignSpaceExplorationBuilder builder() {
+                return new DesignSpaceExplorationBuilderImpl();
+        }
+        List<Transformation> getTransformations();
+        boolean checkAccept();
+        boolean checkExclude();
+        ObjectiveValue getObjectiveValue();
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationBuilder.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationBuilder.java
new file mode 100644
index 00000000..3855a20a
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationBuilder.java
@@ -0,0 +1,59 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition;
+
+import tools.refinery.store.adapter.ModelAdapterBuilder;
+import tools.refinery.store.dse.transition.objectives.Criterion;
+import tools.refinery.store.dse.transition.objectives.Objective;
+
+import java.util.Collection;
+import java.util.List;
+
+public interface DesignSpaceExplorationBuilder extends ModelAdapterBuilder {
+
+        DesignSpaceExplorationBuilder transformation(TransformationRule transformationRuleDefinition);
+        default DesignSpaceExplorationBuilder transformations(TransformationRule... transformationRuleDefinitions) {
+                return transformations(List.of(transformationRuleDefinitions));
+        }
+
+        default DesignSpaceExplorationBuilder transformations(Collection<? extends TransformationRule> transformationRules) {
+                transformationRules.forEach(this::transformation);
+                return this;
+        }
+
+        DesignSpaceExplorationBuilder accept(Criterion criteria);
+
+        default DesignSpaceExplorationBuilder accept(Criterion... criteria) {
+                return accept(List.of(criteria));
+        }
+
+        default DesignSpaceExplorationBuilder accept(Collection<Criterion> criteria) {
+                criteria.forEach(this::accept);
+                return this;
+        }
+
+        DesignSpaceExplorationBuilder exclude(Criterion criteria);
+
+        default DesignSpaceExplorationBuilder exclude(Criterion... criteria) {
+                return exclude(List.of(criteria));
+        }
+
+        default DesignSpaceExplorationBuilder exclude(Collection<Criterion> criteria) {
+                criteria.forEach(this::exclude);
+                return this;
+        }
+
+        DesignSpaceExplorationBuilder objective(Objective objective);
+
+        default DesignSpaceExplorationBuilder objectives(Objective... objectives) {
+                return objectives(List.of(objectives));
+        }
+
+        default DesignSpaceExplorationBuilder objectives(Collection<? extends Objective> objectives) {
+                objectives.forEach(this::objective);
+                return this;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationStoreAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationStoreAdapter.java
new file mode 100644
index 00000000..5c8c7a4d
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationStoreAdapter.java
@@ -0,0 +1,27 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition;
+
+import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.store.dse.transition.objectives.Criterion;
+import tools.refinery.store.dse.transition.objectives.Objective;
+import tools.refinery.store.model.Model;
+
+import java.util.List;
+
+public interface DesignSpaceExplorationStoreAdapter extends ModelStoreAdapter
+{
+        @Override
+        DesignSpaceExplorationAdapter createModelAdapter(Model model);
+
+        List<TransformationRule> getTransformations();
+
+        List<Criterion> getAccepts();
+
+        List<Criterion> getExcludes();
+
+        List<Objective> getObjectives();
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/ObjectiveValue.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/ObjectiveValue.java
new file mode 100644
index 00000000..89ee61c8
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/ObjectiveValue.java
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition;
+
+public interface ObjectiveValue {
+        double get(int index);
+        int getSize();
+
+        static ObjectiveValue of(double v1) {
+                return new ObjectiveValues.ObjectiveValue1(v1);
+        }
+
+        static ObjectiveValue of(double v1, double v2) {
+                return new ObjectiveValues.ObjectiveValue2(v1,v2);
+        }
+
+        static ObjectiveValue of(double[] v) {
+                return new ObjectiveValues.ObjectiveValueN(v);
+        }
+
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/ObjectiveValues.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/ObjectiveValues.java
new file mode 100644
index 00000000..60913ff3
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/ObjectiveValues.java
@@ -0,0 +1,69 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition;
+
+import java.util.Arrays;
+
+public interface ObjectiveValues {
+        public record ObjectiveValue1(double value0) implements ObjectiveValue {
+                @Override
+                public double get(int index) {
+                        if(index == 0) return value0;
+                        else throw new IllegalArgumentException("No value at " + index);
+                }
+
+                @Override
+                public int getSize() {
+                        return 1;
+                }
+        }
+        public record ObjectiveValue2(double value0, double value1) implements ObjectiveValue {
+                @Override
+                public double get(int index) {
+                        if(index == 0) return value0;
+                        else if(index == 1) return value1;
+                        else throw new IllegalArgumentException("No value at " + index);
+                }
+
+                @Override
+                public int getSize() {
+                        return 2;
+                }
+        }
+        public record ObjectiveValueN(double[] values) implements ObjectiveValue {
+                @Override
+                public double get(int index) {
+                        return values[index];
+                }
+
+                @Override
+                public int getSize() {
+                        return values().length;
+                }
+
+                @Override
+                public boolean equals(Object o) {
+                        if (this == o) return true;
+                        if (o == null || getClass() != o.getClass()) return false;
+
+                        ObjectiveValueN that = (ObjectiveValueN) o;
+
+                        return Arrays.equals(values, that.values);
+                }
+
+                @Override
+                public int hashCode() {
+                        return Arrays.hashCode(values);
+                }
+
+                @Override
+                public String toString() {
+                        return "ObjectiveValueN{" +
+                                        "values=" + Arrays.toString(values) +
+                                        '}';
+                }
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/Transformation.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/Transformation.java
new file mode 100644
index 00000000..ab9fda3e
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/Transformation.java
@@ -0,0 +1,44 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition;
+
+import tools.refinery.store.query.resultset.OrderedResultSet;
+import tools.refinery.store.query.resultset.ResultSet;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.function.Consumer;
+
+public class Transformation {
+        private final TransformationRule definition;
+
+        private final OrderedResultSet<Boolean> activations;
+
+        private final Consumer<Tuple> action;
+
+        public Transformation(TransformationRule definition, OrderedResultSet<Boolean> activations, Consumer<Tuple> action) {
+                this.definition = definition;
+                this.activations = activations;
+                this.action = action;
+        }
+
+        public TransformationRule getDefinition() {
+                return definition;
+        }
+
+        public ResultSet<Boolean> getAllActivationsAsResultSet() {
+                return activations;
+        }
+
+        public Tuple getActivation(int index) {
+                return activations.getKey(index);
+        }
+
+        public boolean fireActivation(Tuple activation) {
+                action.accept(activation);
+                //queryEngine.flushChanges();
+                return true;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/TransformationRule.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/TransformationRule.java
new file mode 100644
index 00000000..d64a3db1
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/TransformationRule.java
@@ -0,0 +1,63 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.ModelQueryBuilder;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.dse.ActionFactory;
+import tools.refinery.store.query.resultset.OrderedResultSet;
+import tools.refinery.store.query.resultset.ResultSet;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.*;
+
+public class TransformationRule {
+
+        private final String name;
+        private final RelationalQuery precondition;
+        private final ActionFactory actionFactory;
+
+        private Random random;
+        private ModelQueryAdapter queryEngine;
+
+        public TransformationRule(String name, RelationalQuery precondition, ActionFactory actionFactory) {
+                this(name, precondition, actionFactory, new Random());
+        }
+
+        public TransformationRule(String name, RelationalQuery precondition, ActionFactory actionFactory, long seed) {
+                this(name, precondition, actionFactory, new Random(seed));
+        }
+
+        public TransformationRule(String name, RelationalQuery precondition, ActionFactory actionFactory, Random random) {
+                this.name = name;
+                this.precondition = precondition;
+                this.actionFactory = actionFactory;
+                this.random = random;
+        }
+        public void doConfigure(ModelStoreBuilder storeBuilder) {
+                var queryBuilder = storeBuilder.getAdapter(ModelQueryBuilder.class);
+                queryBuilder.query(this.precondition);
+        }
+
+        public Transformation prepare(Model model) {
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+                var activations = new OrderedResultSet<>(queryEngine.getResultSet(precondition));
+                var action = actionFactory.prepare(model);
+                return new Transformation(this,activations,action);
+        }
+
+        public String getName() {
+                return name;
+        }
+
+        public RelationalQuery getPrecondition() {
+                return precondition;
+        }
+
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/VersionWithObjectiveValue.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/VersionWithObjectiveValue.java
new file mode 100644
index 00000000..ca28e27f
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/VersionWithObjectiveValue.java
@@ -0,0 +1,11 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition;
+
+import tools.refinery.store.map.Version;
+
+public record VersionWithObjectiveValue(Version version, ObjectiveValue objectiveValue) {
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationAdapterImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationAdapterImpl.java
new file mode 100644
index 00000000..e1a29d40
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationAdapterImpl.java
@@ -0,0 +1,90 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.internal;
+
+import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
+import tools.refinery.store.dse.transition.DesignSpaceExplorationStoreAdapter;
+import tools.refinery.store.dse.transition.ObjectiveValue;
+import tools.refinery.store.dse.transition.Transformation;
+import tools.refinery.store.dse.transition.objectives.CriterionCalculator;
+import tools.refinery.store.dse.transition.objectives.ObjectiveCalculator;
+import tools.refinery.store.model.Model;
+
+import java.util.List;
+
+public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExplorationAdapter {
+        final Model model;
+        final DesignSpaceExplorationStoreAdapter designSpaceExplorationStoreAdapter;
+
+        final List<Transformation> transformations;
+        final List<CriterionCalculator> accepts;
+        final List<CriterionCalculator> excludes;
+        final List<ObjectiveCalculator> objectives;
+
+        public DesignSpaceExplorationAdapterImpl(Model model,
+                                                                                         DesignSpaceExplorationStoreAdapter designSpaceExplorationStoreAdapter,
+                                                                                         List<Transformation> transformations,
+                                                                                         List<CriterionCalculator> accepts,
+                                                                                         List<CriterionCalculator> excludes,
+                                                                                         List<ObjectiveCalculator> objectives) {
+                this.model = model;
+                this.designSpaceExplorationStoreAdapter = designSpaceExplorationStoreAdapter;
+
+                this.transformations = transformations;
+                this.accepts = accepts;
+                this.excludes = excludes;
+                this.objectives = objectives;
+        }
+
+        @Override
+        public Model getModel() {
+                return model;
+        }
+
+        @Override
+        public DesignSpaceExplorationStoreAdapter getStoreAdapter() {
+                return designSpaceExplorationStoreAdapter;
+        }
+
+        public List<Transformation> getTransformations() {
+                return transformations;
+        }
+
+        @Override
+        public boolean checkAccept() {
+                for (var accept : this.accepts) {
+                        if (!accept.isSatisfied()) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+
+        @Override
+        public boolean checkExclude() {
+                for (var exclude : this.excludes) {
+                        if (exclude.isSatisfied()) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+
+        @Override
+        public ObjectiveValue getObjectiveValue() {
+                if (objectives.size() == 1) {
+                        return ObjectiveValue.of(objectives.get(0).getValue());
+                } else if (objectives.size() == 2) {
+                        return ObjectiveValue.of(objectives.get(0).getValue(), objectives.get(1).getValue());
+                } else {
+                        double[] res = new double[objectives.size()];
+                        for (int i = 0; i < objectives.size(); i++) {
+                                res[i] = objectives.get(i).getValue();
+                        }
+                        return ObjectiveValue.of(res);
+                }
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationBuilderImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationBuilderImpl.java
new file mode 100644
index 00000000..4371cc03
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationBuilderImpl.java
@@ -0,0 +1,75 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.internal;
+
+import tools.refinery.store.adapter.AbstractModelAdapterBuilder;
+import tools.refinery.store.dse.transition.DesignSpaceExplorationBuilder;
+import tools.refinery.store.dse.transition.TransformationRule;
+import tools.refinery.store.dse.transition.objectives.Criterion;
+import tools.refinery.store.dse.transition.objectives.Objective;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreBuilder;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+
+public class DesignSpaceExplorationBuilderImpl
+                extends AbstractModelAdapterBuilder<DesignSpaceExplorationStoreAdapterImpl>
+                implements DesignSpaceExplorationBuilder {
+
+        LinkedHashSet<TransformationRule> transformationRuleDefinitions = new LinkedHashSet<>();
+        LinkedHashSet<Criterion> accepts = new LinkedHashSet<>();
+        LinkedHashSet<Criterion> excludes = new LinkedHashSet<>();
+        LinkedHashSet<Objective> objectives = new LinkedHashSet<>();
+
+        @Override
+        public DesignSpaceExplorationBuilder transformation(TransformationRule transformationRuleDefinition) {
+                transformationRuleDefinitions.add(transformationRuleDefinition);
+                return this;
+        }
+
+        @Override
+        public DesignSpaceExplorationBuilder accept(Criterion criteria) {
+                accepts.add(criteria);
+                return this;
+        }
+
+        @Override
+        public DesignSpaceExplorationBuilder exclude(Criterion criteria) {
+                excludes.add(criteria);
+                return this;
+        }
+
+
+        @Override
+        public DesignSpaceExplorationBuilder objective(Objective objective) {
+                objectives.add(objective);
+                return this;
+        }
+
+        @Override
+        protected void doConfigure(ModelStoreBuilder storeBuilder) {
+                transformationRuleDefinitions.forEach(x -> x.doConfigure(storeBuilder));
+                accepts.forEach(x -> x.doConfigure(storeBuilder));
+                excludes.forEach(x -> x.doConfigure(storeBuilder));
+                objectives.forEach(x -> x.doConfigure(storeBuilder));
+
+                super.doConfigure(storeBuilder);
+        }
+
+        @Override
+        protected DesignSpaceExplorationStoreAdapterImpl doBuild(ModelStore store) {
+                List<TransformationRule> transformationRuleDefinitiions1 = new ArrayList<>(transformationRuleDefinitions);
+                List<Criterion> accepts1 = new ArrayList<>(accepts);
+                List<Criterion> excludes1 = new ArrayList<>(excludes);
+                List<Objective> objectives1 = new ArrayList<>(objectives);
+
+                return new DesignSpaceExplorationStoreAdapterImpl(store,
+                                transformationRuleDefinitiions1, accepts1,
+                                excludes1, objectives1);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationStoreAdapterImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationStoreAdapterImpl.java
new file mode 100644
index 00000000..3319e148
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationStoreAdapterImpl.java
@@ -0,0 +1,70 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.internal;
+
+import tools.refinery.store.dse.transition.DesignSpaceExplorationStoreAdapter;
+import tools.refinery.store.dse.transition.Transformation;
+import tools.refinery.store.dse.transition.TransformationRule;
+import tools.refinery.store.dse.transition.objectives.Criterion;
+import tools.refinery.store.dse.transition.objectives.CriterionCalculator;
+import tools.refinery.store.dse.transition.objectives.Objective;
+import tools.refinery.store.dse.transition.objectives.ObjectiveCalculator;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+
+import java.util.List;
+
+public class DesignSpaceExplorationStoreAdapterImpl implements DesignSpaceExplorationStoreAdapter {
+        protected final ModelStore store;
+
+        protected final List<TransformationRule> transformationRuleDefinitions;
+        protected final List<Criterion> accepts;
+        protected final List<Criterion> excludes;
+        protected final List<Objective> objectives;
+
+        public DesignSpaceExplorationStoreAdapterImpl(ModelStore store,
+                                                                                                  List<TransformationRule> transformationRuleDefinitions,
+                                                                                                  List<Criterion> accepts, List<Criterion> excludes,
+                                                                                                  List<Objective> objectives) {
+                this.store = store;
+
+                this.transformationRuleDefinitions = transformationRuleDefinitions;
+                this.accepts = accepts;
+                this.excludes = excludes;
+                this.objectives = objectives;
+        }
+
+        @Override
+        public ModelStore getStore() {
+                return store;
+        }
+
+        @Override
+        public DesignSpaceExplorationAdapterImpl createModelAdapter(Model model) {
+                final List<Transformation> t = this.transformationRuleDefinitions.stream().map(x->x.prepare(model)).toList();
+                final List<CriterionCalculator> a = this.accepts.stream().map(x->x.createCalculator(model)).toList();
+                final List<CriterionCalculator> e = this.excludes.stream().map(x->x.createCalculator(model)).toList();
+                final List<ObjectiveCalculator> o = this.objectives.stream().map(x->x.createCalculator(model)).toList();
+
+                return new DesignSpaceExplorationAdapterImpl(model, this, t, a, e, o);
+        }
+        @Override
+        public List<TransformationRule> getTransformations() {
+                return transformationRuleDefinitions;
+        }
+        @Override
+        public List<Criterion> getAccepts() {
+                return accepts;
+        }
+        @Override
+        public List<Criterion> getExcludes() {
+                return excludes;
+        }
+        @Override
+        public List<Objective> getObjectives() {
+                return objectives;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criterion.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criterion.java
new file mode 100644
index 00000000..66ca6f5e
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criterion.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStoreBuilder;
+
+public interface Criterion {
+        default void doConfigure(ModelStoreBuilder storeBuilder) {
+        }
+        CriterionCalculator createCalculator(Model model);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CriterionCalculator.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CriterionCalculator.java
new file mode 100644
index 00000000..944ffed6
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CriterionCalculator.java
@@ -0,0 +1,10 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+public interface CriterionCalculator {
+        boolean isSatisfied();
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objective.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objective.java
new file mode 100644
index 00000000..b5924455
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objective.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStoreBuilder;
+
+public interface Objective {
+        default void doConfigure(ModelStoreBuilder storeBuilder) {
+        }
+        ObjectiveCalculator createCalculator(Model model);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/ObjectiveCalculator.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/ObjectiveCalculator.java
new file mode 100644
index 00000000..f01b8de9
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/ObjectiveCalculator.java
@@ -0,0 +1,10 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+public interface ObjectiveCalculator {
+        double getValue();
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryCriteria.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryCriteria.java
new file mode 100644
index 00000000..e2260cca
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryCriteria.java
@@ -0,0 +1,44 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.ModelQueryBuilder;
+import tools.refinery.store.query.dnf.AnyQuery;
+
+public class QueryCriteria implements Criterion {
+        protected final boolean acceptIfHasMatch;
+        protected final AnyQuery query;
+
+        /**
+         * Criteria based on the existence of matches evaluated on the model.
+         * @param query The query evaluated on the model.
+         * @param acceptIfHasMatch If true, the criteria satisfied if the query has any match on the model. Otherwise,
+         *                            the criteria satisfied if the query has no match on the model.
+         */
+        public QueryCriteria(AnyQuery query, boolean acceptIfHasMatch) {
+                this.query = query;
+                this.acceptIfHasMatch = acceptIfHasMatch;
+        }
+
+        @Override
+        public CriterionCalculator createCalculator(Model model) {
+                var resultSet = model.getAdapter(ModelQueryAdapter.class).getResultSet(query);
+                if(acceptIfHasMatch) {
+                        return () -> resultSet.size() > 0;
+                } else {
+                        return () -> resultSet.size() == 0;
+                }
+        }
+
+        @Override
+        public void doConfigure(ModelStoreBuilder storeBuilder) {
+                Criterion.super.doConfigure(storeBuilder);
+                storeBuilder.getAdapter(ModelQueryBuilder.class).query(query);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryObjective.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryObjective.java
new file mode 100644
index 00000000..dfddccfc
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryObjective.java
@@ -0,0 +1,44 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.ModelQueryBuilder;
+import tools.refinery.store.query.dnf.FunctionalQuery;
+
+public class QueryObjective implements Objective {
+        protected final FunctionalQuery<? extends Number> objectiveFunction;
+
+        public QueryObjective(FunctionalQuery<? extends Number> objectiveFunction) {
+                this.objectiveFunction = objectiveFunction;
+        }
+
+        @Override
+        public ObjectiveCalculator createCalculator(Model model) {
+                var resultSet = model.getAdapter(ModelQueryAdapter.class).getResultSet(objectiveFunction);
+                return () -> {
+                        var cursor = resultSet.getAll();
+                        boolean hasElement = cursor.move();
+                        if(hasElement) {
+                                double result = cursor.getValue().doubleValue();
+                                if(cursor.move()) {
+                                        throw new IllegalStateException("Query providing the objective function has multiple values!");
+                                }
+                                return result;
+                        } else {
+                                throw new IllegalStateException("Query providing the objective function has no values!");
+                        }
+                };
+        }
+
+        @Override
+        public void doConfigure(ModelStoreBuilder storeBuilder) {
+                Objective.super.doConfigure(storeBuilder);
+                storeBuilder.getAdapter(ModelQueryBuilder.class).query(objectiveFunction);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/ActivationStore.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/ActivationStore.java
new file mode 100644
index 00000000..52e0611d
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/ActivationStore.java
@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace;
+
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.map.Version;
+
+import java.util.Random;
+
+public interface ActivationStore {
+        record VisitResult(boolean successfulVisit, boolean mayHaveMore, int transformation, int activation) { }
+        VisitResult markNewAsVisited(VersionWithObjectiveValue to, int[] emptyEntrySizes);
+        boolean hasUnmarkedActivation(VersionWithObjectiveValue version);
+        VisitResult getRandomAndMarkAsVisited(VersionWithObjectiveValue version, Random random);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/EquivalenceClassStore.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/EquivalenceClassStore.java
new file mode 100644
index 00000000..bbe26fe5
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/EquivalenceClassStore.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace;
+
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.statecoding.StateCoderResult;
+
+public interface EquivalenceClassStore {
+        boolean submit(VersionWithObjectiveValue version, StateCoderResult stateCoderResult, int[] emptyActivations, boolean accept);
+        boolean hasUnresolvedSymmetry();
+        void resolveOneSymmetry();
+        int getNumberOfUnresolvedSymmetries();
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/ObjectivePriorityQueue.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/ObjectivePriorityQueue.java
new file mode 100644
index 00000000..df72c343
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/ObjectivePriorityQueue.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace;
+
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.map.Version;
+
+import java.util.Comparator;
+import java.util.Random;
+
+public interface ObjectivePriorityQueue {
+        Comparator<VersionWithObjectiveValue> getComparator();
+        void submit(VersionWithObjectiveValue versionWithObjectiveValue);
+        void remove(VersionWithObjectiveValue versionWithObjectiveValue);
+        int getSize();
+        VersionWithObjectiveValue getBest();
+        VersionWithObjectiveValue getRandom(Random random);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/SolutionStore.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/SolutionStore.java
new file mode 100644
index 00000000..d1bfaa79
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/SolutionStore.java
@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace;
+
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+
+import java.util.List;
+import java.util.concurrent.Future;
+
+public interface SolutionStore {
+        boolean submit(VersionWithObjectiveValue version);
+        List<VersionWithObjectiveValue> getSolutions();
+        boolean hasEnoughSolution();
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/AbstractEquivalenceClassStore.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/AbstractEquivalenceClassStore.java
new file mode 100644
index 00000000..8466a0f3
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/AbstractEquivalenceClassStore.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace.internal;
+
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.dse.transition.statespace.EquivalenceClassStore;
+import tools.refinery.store.statecoding.StateCoderResult;
+import tools.refinery.store.statecoding.StateCoderStoreAdapter;
+
+public abstract class AbstractEquivalenceClassStore implements EquivalenceClassStore {
+        protected final StateCoderStoreAdapter stateCoderStoreAdapter;
+        AbstractEquivalenceClassStore(StateCoderStoreAdapter stateCoderStoreAdapter) {
+                this.stateCoderStoreAdapter = stateCoderStoreAdapter;
+        }
+
+        protected int numberOfUnresolvedSymmetries = 0;
+
+        protected abstract void delegate(VersionWithObjectiveValue version, int[] emptyActivations, boolean accept);
+        protected abstract boolean tryToAdd(StateCoderResult stateCoderResult, VersionWithObjectiveValue newVersion,
+                                                           int[] emptyActivations, boolean accept);
+
+        @Override
+        public synchronized boolean submit(VersionWithObjectiveValue version, StateCoderResult stateCoderResult,
+                                                                           int[] emptyActivations, boolean accept) {
+                boolean hasNewVersion = tryToAdd(stateCoderResult, version, emptyActivations, accept);
+                if (hasNewVersion) {
+                        delegate(version, emptyActivations, accept);
+                        return true;
+                } else {
+                        numberOfUnresolvedSymmetries++;
+                        return false;
+                }
+        }
+
+        @Override
+        public boolean hasUnresolvedSymmetry() {
+                return numberOfUnresolvedSymmetries > 0;
+        }
+
+        @Override
+        public int getNumberOfUnresolvedSymmetries() {
+                return numberOfUnresolvedSymmetries;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreBitVectorEntry.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreBitVectorEntry.java
new file mode 100644
index 00000000..ba243d7d
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreBitVectorEntry.java
@@ -0,0 +1,46 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace.internal;
+
+public class ActivationStoreBitVectorEntry extends ActivationStoreEntry {
+        final int[] selected;
+
+        ActivationStoreBitVectorEntry(int numberOfActivations) {
+                super(numberOfActivations);
+                this.selected = new int[(numberOfActivations / Integer.SIZE) + 1];
+        }
+
+        @Override
+        public int getNumberOfUnvisitedActivations() {
+                int visited = 0;
+                for (int i : selected) {
+                        visited += Integer.bitCount(i);
+                }
+                return visited;
+        }
+
+        private static final int ELEMENT_POSITION = 5; // size of Integer.SIZE
+        private static final int ELEMENT_BITMASK = (1<<ELEMENT_POSITION)-1;
+        @Override
+        public int getAndAddActivationAfter(int index) {
+                int position = index;
+                do {
+                        final int selectedElement = position >> ELEMENT_POSITION;
+                        final int selectedBit = position & ELEMENT_BITMASK;
+                        if((selected[selectedElement] & selectedBit) == 0) {
+                                selected[selectedElement] |= selectedBit;
+                                return position;
+                        } else {
+                                if(position < this.numberOfActivations) {
+                                        position++;
+                                } else {
+                                        position = 0;
+                                }
+                        }
+                } while(position != index);
+                throw  new IllegalArgumentException("There is are no unvisited activations!");
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreEntry.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreEntry.java
new file mode 100644
index 00000000..f69b234c
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreEntry.java
@@ -0,0 +1,32 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace.internal;
+
+public abstract class ActivationStoreEntry {
+        protected final int numberOfActivations;
+
+        ActivationStoreEntry(int numberOfActivations) {
+                this.numberOfActivations = numberOfActivations;
+        }
+
+        public int getNumberOfVisitedActivations() {
+                return numberOfActivations;
+        }
+
+        public abstract int getNumberOfUnvisitedActivations();
+        public abstract int getAndAddActivationAfter(int index);
+
+        //      public abstract boolean contains(int activation)
+        //      public abstract boolean add(int activation)
+
+        public static ActivationStoreEntry create(int size) {
+                if(size <= Integer.SIZE*6) {
+                        return new ActivationStoreBitVectorEntry(size);
+                } else {
+                        return new ActivationStoreListEntry(size);
+                }
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreImpl.java
new file mode 100644
index 00000000..3e59b21a
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreImpl.java
@@ -0,0 +1,131 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace.internal;
+
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.dse.transition.statespace.ActivationStore;
+
+import java.util.*;
+import java.util.function.Consumer;
+
+public class ActivationStoreImpl implements ActivationStore {
+        final int numberOfTransformations;
+        final Consumer<VersionWithObjectiveValue> actionWhenAllActivationVisited;
+        final Map<VersionWithObjectiveValue, List<ActivationStoreEntry>> versionToActivations;
+
+        public ActivationStoreImpl(final int numberOfTransformations,
+                                                           Consumer<VersionWithObjectiveValue> actionWhenAllActivationVisited) {
+                this.numberOfTransformations = numberOfTransformations;
+                this.actionWhenAllActivationVisited = actionWhenAllActivationVisited;
+                versionToActivations = new HashMap<>();
+        }
+
+        public synchronized VisitResult markNewAsVisited(VersionWithObjectiveValue to, int[] emptyEntrySizes) {
+                boolean[] successful = new boolean[]{false};
+                var entries = versionToActivations.computeIfAbsent(to, x -> {
+                        successful[0] = true;
+                        List<ActivationStoreEntry> result = new ArrayList<>(emptyEntrySizes.length);
+                        for(int emptyEntrySize : emptyEntrySizes) {
+                                result.add(ActivationStoreListEntry.create(emptyEntrySize));
+                        }
+                        return result;
+                });
+                boolean hasMore = false;
+                for (var entry : entries) {
+                        if (entry.getNumberOfUnvisitedActivations() > 0) {
+                                hasMore = true;
+                                break;
+                        }
+                }
+                if(!hasMore) {
+                        actionWhenAllActivationVisited.accept(to);
+                }
+                return new VisitResult(successful[0], hasMore, -1, -1);
+        }
+
+        public synchronized VisitResult visitActivation(VersionWithObjectiveValue from, int transformationIndex, int activationIndex) {
+                var entries = versionToActivations.get(from);
+                var entry = entries.get(transformationIndex);
+                final int unvisited = entry.getNumberOfUnvisitedActivations();
+
+                final boolean successfulVisit = unvisited > 0;
+                final boolean hasMoreInActivation = unvisited > 1;
+                final boolean hasMore;
+                final int transformation;
+                final int activation;
+
+                if (successfulVisit) {
+                        transformation = transformationIndex;
+                        activation = entry.getAndAddActivationAfter(activationIndex);
+
+                } else {
+                        transformation = -1;
+                        activation = -1;
+                }
+
+                if(hasMoreInActivation) {
+                        boolean hasMoreInOtherTransformation = false;
+                        for (var e : entries) {
+                                if (e != entry && e.getNumberOfVisitedActivations() > 0) {
+                                        hasMoreInOtherTransformation = true;
+                                        break;
+                                }
+                        }
+                        hasMore = hasMoreInOtherTransformation;
+                } else {
+                        hasMore = true;
+                }
+
+                if(!hasMore) {
+                        actionWhenAllActivationVisited.accept(from);
+                }
+
+                return new VisitResult(false, hasMore, transformation, activation);
+        }
+
+        @Override
+        public synchronized boolean hasUnmarkedActivation(VersionWithObjectiveValue version) {
+                var entries = versionToActivations.get(version);
+                boolean hasMore = false;
+                for (var entry : entries) {
+                        if (entry.getNumberOfUnvisitedActivations() > 0) {
+                                hasMore = true;
+                                break;
+                        }
+                }
+                return hasMore;
+        }
+
+        @Override
+        public synchronized VisitResult getRandomAndMarkAsVisited(VersionWithObjectiveValue version, Random random) {
+                var entries = versionToActivations.get(version);
+
+                int sum1 = 0;
+                for (var entry : entries) {
+                        sum1 += entry.getNumberOfUnvisitedActivations();
+                }
+
+                int selected = random.nextInt(sum1);
+                int sum2 = 0;
+                int transformation = 0;
+                int activation = -1;
+                for (; transformation < entries.size(); transformation++) {
+                        var entry = entries.get(transformation);
+                        int unvisited = entry.getNumberOfUnvisitedActivations();
+                        if (selected < sum2 + unvisited) {
+                                activation = sum2 + unvisited - selected;
+                                break;
+                        } else {
+                                sum2 += unvisited;
+                        }
+                }
+                if (activation == -1) {
+                        throw new IllegalArgumentException("no unvisited");
+                }
+
+                return this.visitActivation(version, transformation, activation);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreListEntry.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreListEntry.java
new file mode 100644
index 00000000..e560f8c5
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreListEntry.java
@@ -0,0 +1,95 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace.internal;
+
+import org.eclipse.collections.api.factory.primitive.IntLists;
+import org.eclipse.collections.api.list.primitive.MutableIntList;
+
+public class ActivationStoreListEntry extends ActivationStoreEntry {
+        private final MutableIntList visitedActivations = IntLists.mutable.empty();
+
+        ActivationStoreListEntry(int numberOfActivations) {
+                super(numberOfActivations);
+        }
+
+        @Override
+        public int getNumberOfUnvisitedActivations() {
+                return this.numberOfActivations - visitedActivations.size();
+        }
+
+        @Override
+        public int getAndAddActivationAfter(int index) {
+                // If it is empty, just add it.
+                if(this.visitedActivations.isEmpty()) {
+                        this.visitedActivations.add(index);
+                        return index;
+                }
+
+                int position = getPosition(index);
+
+                // If the index is not in the position, one can insert it
+                if(this.visitedActivations.get(position) != index) {
+                        this.visitedActivations.addAtIndex(position,index);
+                        return index;
+                }
+
+                // Otherwise, get the next empty space between two elements
+                while(position + 2 < this.visitedActivations.size()) {
+                        position++;
+                        if(this.visitedActivations.get(position+1)-this.visitedActivations.get(position) > 1) {
+                                this.visitedActivations.addAtIndex(position+1, this.visitedActivations.get(position+1)+1);
+                        }
+                }
+
+                // Otherwise, try to add to the last space
+                int last = this.visitedActivations.get(this.visitedActivations.size()-1);
+                if(last<this.numberOfActivations) {
+                        this.visitedActivations.add(last+1);
+                        return last+1;
+                }
+
+                // Otherwise, try to put to the beginning
+                if(this.visitedActivations.get(0) > 0) {
+                        this.visitedActivations.add(0);
+                        return 0;
+                }
+
+                // Otherwise, get the next empty space between two elements
+                position = 0;
+                while(position + 2 < this.visitedActivations.size()) {
+                        position++;
+                        if(this.visitedActivations.get(position+1)-this.visitedActivations.get(position) > 1) {
+                                this.visitedActivations.addAtIndex(position+1, this.visitedActivations.get(position+1)+1);
+                        }
+                }
+
+                throw new IllegalArgumentException("There is are no unvisited activations!");
+        }
+
+        /**
+         * Returns the position of an index in the {@code visitedActivations}. If the collection contains the index, in
+         * returns its position, otherwise, it  returns the position where the index need to be put.
+         *
+         * @param index Index of an activation.
+         * @return The position of the index.
+         */
+        private int getPosition(int index) {
+                int left = 0;
+                int right = this.visitedActivations.size() - 1;
+                while (left <= right) {
+                        final int middle = (right - left) / 2 + left;
+                        final int middleElement = visitedActivations.get(middle);
+                        if(middleElement == index) {
+                                return middle;
+                        } else if(middleElement < index) {
+                                left = middle +1;
+                        } else{
+                                right = middle-1;
+                        }
+                }
+                return right+1;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreWorker.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreWorker.java
new file mode 100644
index 00000000..e05f5122
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreWorker.java
@@ -0,0 +1,56 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace.internal;
+
+import tools.refinery.store.dse.transition.Transformation;
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.dse.transition.statespace.ActivationStore;
+import tools.refinery.store.map.Version;
+
+import java.util.List;
+import java.util.Random;
+
+public class ActivationStoreWorker {
+        final ActivationStore store;
+        final List<Transformation> transformations;
+
+        public ActivationStoreWorker(ActivationStore store, List<Transformation> transformations) {
+                this.store = store;
+                this.transformations = transformations;
+        }
+
+        public int[] calculateEmptyActivationSize() {
+                int[] result = new int[transformations.size()];
+                for (int i = 0; i < result.length; i++) {
+                        result[i] = transformations.get(i).getAllActivationsAsResultSet().size();
+                }
+                return result;
+        }
+
+
+        public ActivationStore.VisitResult fireRandomActivation(VersionWithObjectiveValue thisVersion, Random random) {
+                var result = store.getRandomAndMarkAsVisited(thisVersion, random);
+                if(result.successfulVisit()) {
+                        int selectedTransformation = result.transformation();
+                        int selectedActivation = result.activation();
+
+                        Transformation transformation = transformations.get(selectedTransformation);
+                        var tuple = transformation.getActivation(selectedActivation);
+
+                        boolean success = transformation.fireActivation(tuple);
+                        if(success) {
+                                return result;
+                        } else {
+                                return new ActivationStore.VisitResult(
+                                                false,
+                                                result.mayHaveMore(),
+                                                selectedActivation,
+                                                selectedActivation);
+                        }
+                }
+                return result;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/CompleteEquivalenceClassStore.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/CompleteEquivalenceClassStore.java
new file mode 100644
index 00000000..20a026b6
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/CompleteEquivalenceClassStore.java
@@ -0,0 +1,104 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace.internal;
+
+import org.eclipse.collections.api.factory.primitive.IntObjectMaps;
+import org.eclipse.collections.api.map.primitive.MutableIntObjectMap;
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.dse.transition.statespace.EquivalenceClassStore;
+import tools.refinery.store.statecoding.StateCoderResult;
+import tools.refinery.store.statecoding.StateCoderStoreAdapter;
+import tools.refinery.store.statecoding.StateEquivalenceChecker;
+
+import java.util.ArrayList;
+
+public abstract class CompleteEquivalenceClassStore extends AbstractEquivalenceClassStore implements EquivalenceClassStore {
+
+        static class SymmetryStoreArray extends ArrayList<VersionWithObjectiveValue> {
+                final int[] activationSizes;
+                final boolean accept;
+
+                SymmetryStoreArray(int[] activationSizes, boolean accept) {
+                        super();
+                        this.activationSizes = activationSizes;
+                        this.accept = accept;
+                }
+        }
+
+        private final MutableIntObjectMap<Object> modelCode2Versions = IntObjectMaps.mutable.empty();
+
+        protected CompleteEquivalenceClassStore(StateCoderStoreAdapter stateCoderStoreAdapter) {
+                super(stateCoderStoreAdapter);
+        }
+
+        @Override
+        protected boolean tryToAdd(StateCoderResult stateCoderResult, VersionWithObjectiveValue newVersion,
+                                           int[] emptyActivations, boolean accept) {
+                int modelCode = stateCoderResult.modelCode();
+                Object old = modelCode2Versions.updateValue(
+                                modelCode,
+                                () -> newVersion,
+                                x -> {
+                                        if (x instanceof SymmetryStoreArray array) {
+                                                if(array.accept != accept || array.activationSizes != emptyActivations) {
+                                                        this.delegate(newVersion,emptyActivations,accept);
+                                                        return x;
+                                                }
+                                                array.add(newVersion);
+                                                return array;
+                                        } else {
+                                                SymmetryStoreArray result = new SymmetryStoreArray(emptyActivations, accept);
+                                                result.add((VersionWithObjectiveValue) x);
+                                                result.add(newVersion);
+                                                return result;
+                                        }
+                                });
+                return old == null;
+        }
+
+        @Override
+        public void resolveOneSymmetry() {
+                var unresolvedSimilarity = getOneUnresolvedSymmetry();
+                if (unresolvedSimilarity == null) {
+                        return;
+                }
+                var outcome = this.stateCoderStoreAdapter.checkEquivalence(unresolvedSimilarity.get(0).version(),
+                                unresolvedSimilarity.get(1).version());
+                if (outcome != StateEquivalenceChecker.EquivalenceResult.ISOMORPHIC) {
+                        delegate(unresolvedSimilarity.get(1), unresolvedSimilarity.activationSizes, unresolvedSimilarity.accept);
+                }
+        }
+
+        //record  UnresolvedSymmetryResult
+
+        private synchronized SymmetryStoreArray getOneUnresolvedSymmetry() {
+                if (numberOfUnresolvedSymmetries <= 0) {
+                        return null;
+                }
+
+                for (var entry : modelCode2Versions.keyValuesView()) {
+                        int hash = entry.getOne();
+                        var value = entry.getTwo();
+                        if (value instanceof SymmetryStoreArray array) {
+                                int size = array.size();
+                                var representative = array.get(0);
+                                var similar = array.get(size - 1);
+                                array.remove(size - 1);
+
+                                if (size <= 2) {
+                                        modelCode2Versions.put(hash, representative);
+                                }
+
+                                var result = new SymmetryStoreArray(array.activationSizes, array.accept);
+                                result.add(representative);
+                                result.add(similar);
+                                return result;
+                        }
+                }
+
+                return null;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/FastEquivalenceClassStore.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/FastEquivalenceClassStore.java
new file mode 100644
index 00000000..6ee8e196
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/FastEquivalenceClassStore.java
@@ -0,0 +1,32 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace.internal;
+
+import org.eclipse.collections.api.factory.primitive.IntSets;
+import org.eclipse.collections.api.set.primitive.MutableIntSet;
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.dse.transition.statespace.EquivalenceClassStore;
+import tools.refinery.store.statecoding.StateCoderResult;
+import tools.refinery.store.statecoding.StateCoderStoreAdapter;
+
+public abstract class FastEquivalenceClassStore extends AbstractEquivalenceClassStore implements EquivalenceClassStore {
+
+        private final MutableIntSet codes = IntSets.mutable.empty();
+
+        public FastEquivalenceClassStore(StateCoderStoreAdapter stateCoderStoreAdapter) {
+                super(stateCoderStoreAdapter);
+        }
+
+        @Override
+        protected boolean tryToAdd(StateCoderResult stateCoderResult, VersionWithObjectiveValue newVersion, int[] emptyActivations, boolean accept) {
+                return this.codes.add(stateCoderResult.modelCode());
+        }
+
+        @Override
+        public void resolveOneSymmetry() {
+                throw new IllegalArgumentException("This equivalence storage is not prepared to resolve symmetries!");
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ObjectivePriorityQueueImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ObjectivePriorityQueueImpl.java
new file mode 100644
index 00000000..249b22da
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ObjectivePriorityQueueImpl.java
@@ -0,0 +1,74 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace.internal;
+
+import tools.refinery.store.dse.transition.ObjectiveValues;
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.dse.transition.objectives.Objective;
+import tools.refinery.store.dse.transition.statespace.ObjectivePriorityQueue;
+import tools.refinery.store.map.Version;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.PriorityQueue;
+import java.util.Random;
+
+public class ObjectivePriorityQueueImpl implements ObjectivePriorityQueue {
+        public static final Comparator<VersionWithObjectiveValue> c1 = (o1, o2) -> Double.compare(
+                        ((ObjectiveValues.ObjectiveValue1) o1.objectiveValue()).value0(),
+                        ((ObjectiveValues.ObjectiveValue1) o2.objectiveValue()).value0());
+        // TODO: support multi objective!
+        final PriorityQueue<VersionWithObjectiveValue> priorityQueue;
+
+        public ObjectivePriorityQueueImpl(List<Objective> objectives) {
+
+                if(objectives.size() == 1) {
+                        this.priorityQueue = new PriorityQueue<>(c1);
+                } else {
+                        throw new UnsupportedOperationException("Only single objective comparator is implemented currently!");
+                }
+        }
+        @Override
+        public Comparator<VersionWithObjectiveValue> getComparator() {
+                return c1;
+        }
+
+        @Override
+        public void submit(VersionWithObjectiveValue versionWithObjectiveValue) {
+                priorityQueue.add(versionWithObjectiveValue);
+        }
+
+        @Override
+        public void remove(VersionWithObjectiveValue versionWithObjectiveValue) {
+                priorityQueue.remove(versionWithObjectiveValue);
+        }
+
+        @Override
+        public int getSize() {
+                return priorityQueue.size();
+        }
+
+        @Override
+        public VersionWithObjectiveValue getBest() {
+                var best = priorityQueue.peek();
+                if (best != null) {
+                        return best;
+                } else {
+                        throw new IllegalArgumentException("The objective store is empty!");
+                }
+        }
+
+        @Override
+        public VersionWithObjectiveValue getRandom(Random random) {
+                int randomPosition = random.nextInt(getSize());
+                for (VersionWithObjectiveValue entry : this.priorityQueue) {
+                        if (randomPosition-- == 0) {
+                                return entry;
+                        }
+                }
+                throw new IllegalStateException("The priority queue is inconsistent!");
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/SolutionStoreImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/SolutionStoreImpl.java
new file mode 100644
index 00000000..cc48864f
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/SolutionStoreImpl.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace.internal;
+
+import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
+import tools.refinery.store.dse.transition.statespace.SolutionStore;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+public class SolutionStoreImpl implements SolutionStore {
+        final int maxNumberSolutions;
+        public static final int UNLIMITED = -1;
+        final SortedSet<VersionWithObjectiveValue> solutions;
+
+        public SolutionStoreImpl(int maxNumberSolutions) {
+                this.maxNumberSolutions = maxNumberSolutions;
+                solutions = new TreeSet<>(ObjectivePriorityQueueImpl.c1);
+        }
+
+
+        @Override
+        public synchronized boolean submit(VersionWithObjectiveValue version) {
+                boolean removeLast = hasEnoughSolution();
+                solutions.add(version);
+                if(removeLast) {
+                        var last = solutions.last();
+                        solutions.remove(last);
+                        return last != version;
+                } else {
+                        return true;
+                }
+        }
+
+        @Override
+        public List<VersionWithObjectiveValue> getSolutions() {
+                return new ArrayList<>(solutions);
+        }
+
+        @Override
+        public boolean hasEnoughSolution() {
+                if (maxNumberSolutions == UNLIMITED) {
+                        return false;
+                } else {
+                        return solutions.size() >= maxNumberSolutions;
+                }
+        }
+}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/CRAExamplesTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/CRAExamplesTest.java
new file mode 100644
index 00000000..36517709
--- /dev/null
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/CRAExamplesTest.java
@@ -0,0 +1,277 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse;
+
+import tools.refinery.store.dse.transition.TransformationRule;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.view.AnySymbolView;
+import tools.refinery.store.query.view.KeyOnlyView;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.List;
+
+import static tools.refinery.store.query.literal.Literals.not;
+
+class CRAExamplesTest {
+
+        private static final Symbol<String> name = Symbol.of("Name", 1, String.class);
+
+//      private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
+        private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1);
+//      private static final Symbol<Boolean> feature = Symbol.of("Feature", 1);
+        private static final Symbol<Boolean> attribute = Symbol.of("Attribute", 1);
+        private static final Symbol<Boolean> method = Symbol.of("Method", 1);
+
+//      private static final Symbol<Boolean> isEncapsulatedBy = Symbol.of("IsEncapsulatedBy", 2);
+        private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2);
+        private static final Symbol<Boolean> dataDependency = Symbol.of("DataDependency", 2);
+        private static final Symbol<Boolean> functionalDependency = Symbol.of("FunctionalDependency", 2);
+
+        private static final Symbol<Boolean> features = Symbol.of("Features", 2);
+        private static final Symbol<Boolean> classes = Symbol.of("Classes", 2);
+
+//      private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel);
+        private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement);
+//      private static final AnySymbolView featureView = new KeyOnlyView<>(feature);
+        private static final AnySymbolView attributeView = new KeyOnlyView<>(attribute);
+        private static final AnySymbolView methodView = new KeyOnlyView<>(method);
+//      private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
+        private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
+        private static final AnySymbolView dataDependencyView = new KeyOnlyView<>(dataDependency);
+        private static final AnySymbolView functionalDependencyView = new KeyOnlyView<>(functionalDependency);
+        private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
+        private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
+
+        /*Example Transformation rules*/
+        private static final RelationalQuery feature = Query.of("Feature",
+                        (builder, f) -> builder.clause(
+                                attributeView.call(f))
+                        .clause(
+                                methodView.call(f))
+                        );
+
+        private static final RelationalQuery assignFeaturePreconditionHelper = Query.of("AssignFeaturePreconditionHelper",
+                        (builder, c, f) -> builder.clause(
+                                        classElementView.call(c),
+//                                      classesView.call(model, c),
+                                        encapsulatesView.call(c, f)
+                        ));
+
+        private static final RelationalQuery assignFeaturePrecondition = Query.of("AssignFeaturePrecondition",
+                        (builder, f, c1) -> builder.clause((c2) -> List.of(
+//                                      classModelView.call(model),
+                                        feature.call(f),
+                                        classElementView.call(c1),
+//                                      featuresView.call(model, f),
+                                        not(assignFeaturePreconditionHelper.call(c2, f)),
+                                        not(encapsulatesView.call(c1, f))
+                        )));
+
+        private static final RelationalQuery deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
+                        (builder, c) -> builder.clause((f) -> List.of(
+//                                      classModelView.call(model),
+                                        classElementView.call(c),
+//                                      featuresView.call(model, f),
+                                        not(encapsulatesView.call(c, f))
+                        )));
+
+        private static final RelationalQuery createClassPreconditionHelper = Query.of("CreateClassPreconditionHelper",
+                        (builder, f, c) -> builder.clause(
+                                        classElementView.call(c),
+//                                      classesView.call(model, c),
+                                        encapsulatesView.call(c, f)
+                        ));
+
+        private static final RelationalQuery createClassPrecondition = Query.of("CreateClassPrecondition",
+                        (builder, f) -> builder.clause((c) -> List.of(
+//                                      classModelView.call(model),
+                                        feature.call(f),
+                                        not(createClassPreconditionHelper.call(f, c))
+                        )));
+
+        private static final RelationalQuery moveFeaturePrecondition = Query.of("MoveFeature",
+                        (builder, c1, c2, f) -> builder.clause(
+//                                      classModelView.call(model),
+                                        classElementView.call(c1),
+                                        classElementView.call(c2),
+                                        c1.notEquivalent(c2),
+                                        feature.call(f),
+//                                      classesView.call(model, c1),
+//                                      classesView.call(model, c2),
+//                                      featuresView.call(model, f),
+                                        encapsulatesView.call(c1, f)
+                        ));
+
+        private static final TransformationRule assignFeatureRule = new TransformationRule("AssignFeature",
+                        assignFeaturePrecondition,
+                        (model) -> {
+//                              var isEncapsulatedByInterpretation = model.getInterpretation(isEncapsulatedBy);
+                                var encapsulatesInterpretation = model.getInterpretation(encapsulates);
+                                return ((Tuple activation) -> {
+                                        var feature = activation.get(0);
+                                        var classElement = activation.get(1);
+
+//                                      isEncapsulatedByInterpretation.put(Tuple.of(feature, classElement), true);
+                                        encapsulatesInterpretation.put(Tuple.of(classElement, feature), true);
+                                });
+                        });
+
+//      private static final TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass",
+//                      deleteEmptyClassPrecondition,
+//                      (model) -> {
+////                            var classesInterpretation = model.getInterpretation(classes);
+//                              var classElementInterpretation = model.getInterpretation(classElement);
+//                              return ((Tuple activation) -> {
+//                                      // TODO: can we move dseAdapter outside?
+//                                      var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+////                                    var modelElement = activation.get(0);
+//                                      var classElement = activation.get(0);
+//
+////                                    classesInterpretation.put(Tuple.of(modelElement, classElement), false);
+//                                      classElementInterpretation.put(Tuple.of(classElement), false);
+//                                      dseAdapter.deleteObject(Tuple.of(classElement));
+//                              });
+//                      });
+
+//      private static final TransformationRule createClassRule = new TransformationRule("CreateClass",
+//                      createClassPrecondition,
+//                      (model) -> {
+//                              var classElementInterpretation = model.getInterpretation(classElement);
+////                            var classesInterpretation = model.getInterpretation(classes);
+//                              var encapsulatesInterpretation = model.getInterpretation(encapsulates);
+//                              return ((Tuple activation) -> {
+//                                      // TODO: can we move dseAdapter outside?
+//                                      var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+////                                    var modelElement = activation.get(0);
+//                                      var feature = activation.get(0);
+//
+//                                      var newClassElement = dseAdapter.createObject();
+//                                      var newClassElementId = newClassElement.get(0);
+//                                      classElementInterpretation.put(newClassElement, true);
+////                                    classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                      encapsulatesInterpretation.put(Tuple.of(newClassElementId, feature), true);
+//                              });
+//                      });
+
+        private static final TransformationRule moveFeatureRule = new TransformationRule("MoveFeature",
+                        moveFeaturePrecondition,
+                        (model) -> {
+                                var encapsulatesInterpretation = model.getInterpretation(encapsulates);
+                                return ((Tuple activation) -> {
+                                        var classElement1 = activation.get(0);
+                                        var classElement2 = activation.get(1);
+                                        var feature = activation.get(2);
+
+                                        encapsulatesInterpretation.put(Tuple.of(classElement1, feature), false);
+                                        encapsulatesInterpretation.put(Tuple.of(classElement2, feature), true);
+                                });
+                        });
+
+//      @Test
+//      @Disabled("This test is only for debugging purposes")
+//      void craTest() {
+//              var store = ModelStore.builder()
+//                              .symbols(classElement, encapsulates, classes, features, attribute, method, dataDependency,
+//                                              functionalDependency, name)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(feature, assignFeaturePreconditionHelper, assignFeaturePrecondition,
+//                                                              deleteEmptyClassPrecondition, createClassPreconditionHelper, createClassPrecondition,
+//                                                              moveFeaturePrecondition))
+//                              .with(ModelVisualizerAdapter.builder()
+//                                              .withOutputpath("test_output")
+//                                              .withFormat(FileFormat.DOT)
+//                                              .withFormat(FileFormat.SVG)
+//                                              .saveStates()
+//                                              .saveDesignSpace()
+//                              )
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .transformations(assignFeatureRule, deleteEmptyClassRule, createClassRule, moveFeatureRule)
+//                                              .objectives(new AlwaysSatisfiedRandomHardObjective())
+////                                            .strategy(new DepthFirstStrategy().withDepthLimit(3).continueIfHardObjectivesFulfilled()
+//                                              .strategy(new BestFirstStrategy().withDepthLimit(6).continueIfHardObjectivesFulfilled()
+////                                                            .goOnOnlyIfFitnessIsBetter()
+//                                              ))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+////            dseAdapter.setRandom(1);
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//
+////            var modelInterpretation = model.getInterpretation(classModel);
+//              var nameInterpretation = model.getInterpretation(name);
+//              var methodInterpretation = model.getInterpretation(method);
+//              var attributeInterpretation = model.getInterpretation(attribute);
+//              var dataDependencyInterpretation = model.getInterpretation(dataDependency);
+//              var functionalDependencyInterpretation = model.getInterpretation(functionalDependency);
+//
+////            var modelElement = dseAdapter.createObject();
+//              var method1 = dseAdapter.createObject();
+//              var method1Id = method1.get(0);
+//              var method2 = dseAdapter.createObject();
+//              var method2Id = method2.get(0);
+//              var method3 = dseAdapter.createObject();
+//              var method3Id = method3.get(0);
+//              var method4 = dseAdapter.createObject();
+//              var method4Id = method4.get(0);
+//              var attribute1 = dseAdapter.createObject();
+//              var attribute1Id = attribute1.get(0);
+//              var attribute2 = dseAdapter.createObject();
+//              var attribute2Id = attribute2.get(0);
+//              var attribute3 = dseAdapter.createObject();
+//              var attribute3Id = attribute3.get(0);
+//              var attribute4 = dseAdapter.createObject();
+//              var attribute4Id = attribute4.get(0);
+//              var attribute5 = dseAdapter.createObject();
+//              var attribute5Id = attribute5.get(0);
+//
+//              nameInterpretation.put(method1, "M1");
+//              nameInterpretation.put(method2, "M2");
+//              nameInterpretation.put(method3, "M3");
+//              nameInterpretation.put(method4, "M4");
+//              nameInterpretation.put(attribute1, "A1");
+//              nameInterpretation.put(attribute2, "A2");
+//              nameInterpretation.put(attribute3, "A3");
+//              nameInterpretation.put(attribute4, "A4");
+//              nameInterpretation.put(attribute5, "A5");
+//
+//
+//
+////            modelInterpretation.put(modelElement, true);
+//              methodInterpretation.put(method1, true);
+//              methodInterpretation.put(method2, true);
+//              methodInterpretation.put(method3, true);
+//              methodInterpretation.put(method4, true);
+//              attributeInterpretation.put(attribute1, true);
+//              attributeInterpretation.put(attribute2, true);
+//              attributeInterpretation.put(attribute3, true);
+//              attributeInterpretation.put(attribute4, true);
+//              attributeInterpretation.put(attribute5, true);
+//
+//              dataDependencyInterpretation.put(Tuple.of(method1Id, attribute1Id), true);
+//              dataDependencyInterpretation.put(Tuple.of(method1Id, attribute3Id), true);
+//              dataDependencyInterpretation.put(Tuple.of(method2Id, attribute2Id), true);
+//              dataDependencyInterpretation.put(Tuple.of(method3Id, attribute3Id), true);
+//              dataDependencyInterpretation.put(Tuple.of(method3Id, attribute4Id), true);
+//              dataDependencyInterpretation.put(Tuple.of(method4Id, attribute3Id), true);
+//              dataDependencyInterpretation.put(Tuple.of(method4Id, attribute5Id), true);
+//
+//              functionalDependencyInterpretation.put(Tuple.of(method1Id, attribute3Id), true);
+//              functionalDependencyInterpretation.put(Tuple.of(method1Id, attribute4Id), true);
+//              functionalDependencyInterpretation.put(Tuple.of(method2Id, attribute1Id), true);
+//              functionalDependencyInterpretation.put(Tuple.of(method3Id, attribute1Id), true);
+//              functionalDependencyInterpretation.put(Tuple.of(method3Id, attribute4Id), true);
+//              functionalDependencyInterpretation.put(Tuple.of(method4Id, attribute2Id), true);
+//
+//              queryEngine.flushChanges();
+//
+//              var states = dseAdapter.explore();
+//              System.out.println("states size: " + states.size());
+//      }
+//*/
+}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DebugTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DebugTest.java
new file mode 100644
index 00000000..1d757a5f
--- /dev/null
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DebugTest.java
@@ -0,0 +1,116 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse;
+
+import tools.refinery.store.query.view.AnySymbolView;
+import tools.refinery.store.query.view.KeyOnlyView;
+import tools.refinery.store.representation.Symbol;
+
+class DebugTest {
+        private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
+        private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1);
+        private static final Symbol<Boolean> feature = Symbol.of("Feature", 1);
+
+        private static final Symbol<Boolean> isEncapsulatedBy = Symbol.of("IsEncapsulatedBy", 2);
+        private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2);
+
+        private static final Symbol<Boolean> features = Symbol.of("Features", 2);
+        private static final Symbol<Boolean> classes = Symbol.of("Classes", 2);
+
+        private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel);
+        private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement);
+        private static final AnySymbolView featureView = new KeyOnlyView<>(feature);
+        private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
+        private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
+        private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
+        private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
+
+
+//      @Test
+//      @Disabled("This test is only for debugging purposes")
+//      void BFSTest() {
+//              var createClassPrecondition = Query.of("CreateClassPrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createClassRule = new TransformationRule("CreateClass",
+//                              createClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createFeatureRule = new TransformationRule("CreateFeature",
+//                              createFeaturePrecondition,
+//                              (model) -> {
+//                                      var featuresInterpretation = model.getInterpretation(features);
+//                                      var featureInterpretation = model.getInterpretation(feature);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              featureInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var store = ModelStore.builder()
+//                              .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(createClassPrecondition, createFeaturePrecondition))
+//                              .with(ModelVisualizerAdapter.builder()
+//                                              .withOutputpath("test_output")
+//                                              .withFormat(FileFormat.DOT)
+//                                              .withFormat(FileFormat.SVG)
+//                                              .saveStates()
+//                                              .saveDesignSpace()
+//                              )
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .transformations(createClassRule, createFeatureRule)
+//                                              .objectives(new AlwaysSatisfiedRandomHardObjective())
+//                                              .strategy(new DepthFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
+////                                            .strategy(new BestFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
+////                                                            .goOnOnlyIfFitnessIsBetter()
+//                                              ))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+////            dseAdapter.setRandom(1);
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//
+//              var modelElementInterpretation = model.getInterpretation(classModel);
+//              var classElementInterpretation = model.getInterpretation(classElement);
+//              var modelElement = dseAdapter.createObject();
+//              modelElementInterpretation.put(modelElement, true);
+//              classElementInterpretation.put(modelElement, true);
+//              queryEngine.flushChanges();
+//
+//
+//              var states = dseAdapter.explore();
+//              System.out.println("states size: " + states.size());
+//
+//      }
+}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DesignSpaceExplorationTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DesignSpaceExplorationTest.java
new file mode 100644
index 00000000..f5f13433
--- /dev/null
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DesignSpaceExplorationTest.java
@@ -0,0 +1,596 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse;
+
+import tools.refinery.store.query.view.AnySymbolView;
+import tools.refinery.store.query.view.KeyOnlyView;
+import tools.refinery.store.representation.Symbol;
+
+class DesignSpaceExplorationTest {
+//      private static final Symbol<Boolean> namedElement = Symbol.of("NamedElement", 1);
+//      private static final Symbol<Boolean> attribute = Symbol.of("Attribute", 1);
+//      private static final Symbol<Boolean> method = Symbol.of("Method", 1);
+//      private static final Symbol<Boolean> dataDependency = Symbol.of("DataDependency", 2);
+//      private static final Symbol<Boolean> functionalDependency = Symbol.of("FunctionalDependency", 2);
+
+        private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
+        private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1);
+        private static final Symbol<Boolean> feature = Symbol.of("Feature", 1);
+
+        private static final Symbol<Boolean> isEncapsulatedBy = Symbol.of("IsEncapsulatedBy", 2);
+        private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2);
+
+        private static final Symbol<Boolean> features = Symbol.of("Features", 2);
+        private static final Symbol<Boolean> classes = Symbol.of("Classes", 2);
+
+        private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel);
+        private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement);
+        private static final AnySymbolView featureView = new KeyOnlyView<>(feature);
+        private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
+        private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
+        private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
+        private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
+
+//      @Test
+//      void createObjectTest() {
+//              var store = ModelStore.builder()
+//                              .with(ViatraModelQueryAdapter.builder())
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//
+//              assertEquals(0, dseAdapter.getModelSize());
+//
+//              var newModel = dseAdapter.createObject();
+//              var newModelId = newModel.get(0);
+//              var newClass1 = dseAdapter.createObject();
+//              var newClass1Id = newClass1.get(0);
+//              var newClass2 = dseAdapter.createObject();
+//              var newClass2Id = newClass2.get(0);
+//              var newField = dseAdapter.createObject();
+//              var newFieldId = newField.get(0);
+//
+//              assertEquals(0, newModelId);
+//              assertEquals(1, newClass1Id);
+//              assertEquals(2, newClass2Id);
+//              assertEquals(3, newFieldId);
+//              assertEquals(4, dseAdapter.getModelSize());
+//      }
+
+//      @Test
+//      void deleteMiddleObjectTest() {
+//              var store = ModelStore.builder()
+//                              .with(ViatraModelQueryAdapter.builder())
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .strategy(new DepthFirstStrategy()))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//
+//              assertEquals(0, dseAdapter.getModelSize());
+//
+//              var newObject0 = dseAdapter.createObject();
+//              var newObject0Id = newObject0.get(0);
+//              var newObject1 = dseAdapter.createObject();
+//              var newObject1Id = newObject1.get(0);
+//              var newObject2 = dseAdapter.createObject();
+//              var newObject2Id = newObject2.get(0);
+//              var newObject3 = dseAdapter.createObject();
+//              var newObject3Id = newObject3.get(0);
+//
+//              assertEquals(0, newObject0Id);
+//              assertEquals(1, newObject1Id);
+//              assertEquals(2, newObject2Id);
+//              assertEquals(3, newObject3Id);
+//              assertEquals(4, dseAdapter.getModelSize());
+//
+//              dseAdapter.deleteObject(newObject1);
+//              assertEquals(4, dseAdapter.getModelSize());
+//
+//              var newObject4 = dseAdapter.createObject();
+//              var newObject4Id = newObject4.get(0);
+//              assertEquals(4, newObject4Id);
+//              assertEquals(5, dseAdapter.getModelSize());
+//
+//              dseAdapter.deleteObject(newObject4);
+//              assertEquals(5, dseAdapter.getModelSize());
+//      }
+//
+//      @Test
+//      void DFSTrivialTest() {
+//              var store = ModelStore.builder()
+//                              .symbols(classModel)
+//                              .with(ViatraModelQueryAdapter.builder())
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//
+//              var states = dseAdapter.explore();
+//              assertEquals(1, states.size());
+//      }
+//
+//      @Test
+//      void DFSOneRuleTest() {
+//              var createClassPrecondition = Query.of("CreateClassPrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createClassRule = new TransformationRule("CreateClass",
+//                              createClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var store = ModelStore.builder()
+//                              .symbols(classModel, classElement, classes)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(createClassPrecondition))
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .transformations(createClassRule)
+//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)
+//                                              ))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//
+//              var modelElementInterpretation = model.getInterpretation(classModel);
+//              modelElementInterpretation.put(dseAdapter.createObject(), true);
+//              queryEngine.flushChanges();
+//
+//              var states = dseAdapter.explore();
+//              assertEquals(1, states.size());
+//      }
+//
+//      @Test
+//      void DFSContinueTest() {
+//              var createClassPrecondition = Query.of("CreateClassPrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createClassRule = new TransformationRule("CreateClass",
+//                              createClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var store = ModelStore.builder()
+//                              .symbols(classModel, classElement, classes)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(createClassPrecondition))
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .transformations(createClassRule)
+//                                              .strategy(new DepthFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
+//                                              ))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//
+//              var modelElementInterpretation = model.getInterpretation(classModel);
+//              modelElementInterpretation.put(dseAdapter.createObject(), true);
+//              queryEngine.flushChanges();
+//
+//              var states = dseAdapter.explore();
+//              assertEquals(5, states.size());
+//      }
+//
+//      @Test
+//      void DFSCompletenessTest() {
+//              var createClassPrecondition = Query.of("CreateClassPrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createClassRule = new TransformationRule("CreateClass",
+//                              createClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createFeatureRule = new TransformationRule("CreateFeature",
+//                              createFeaturePrecondition,
+//                              (model) -> {
+//                                      var featuresInterpretation = model.getInterpretation(features);
+//                                      var featureInterpretation = model.getInterpretation(feature);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              featureInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var store = ModelStore.builder()
+//                              .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(createClassPrecondition, createFeaturePrecondition))
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .transformations(createClassRule, createFeatureRule)
+//                                              .strategy(new DepthFirstStrategy().withDepthLimit(10).continueIfHardObjectivesFulfilled()
+//                                              ))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//
+//              var modelElementInterpretation = model.getInterpretation(classModel);
+//              modelElementInterpretation.put(dseAdapter.createObject(), true);
+//              queryEngine.flushChanges();
+//
+//              var states = dseAdapter.explore();
+//              assertEquals(2047, states.size());
+//      }
+//
+//      @Test
+//      void DFSSolutionLimitTest() {
+//              var createClassPrecondition = Query.of("CreateClassPrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createClassRule = new TransformationRule("CreateClass",
+//                              createClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createFeatureRule = new TransformationRule("CreateFeature",
+//                              createFeaturePrecondition,
+//                              (model) -> {
+//                                      var featuresInterpretation = model.getInterpretation(features);
+//                                      var featureInterpretation = model.getInterpretation(feature);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              featureInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var store = ModelStore.builder()
+//                              .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(createClassPrecondition, createFeaturePrecondition))
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .transformations(createClassRule, createFeatureRule)
+//                                              .strategy(new DepthFirstStrategy().withSolutionLimit(222)
+//                                                              .continueIfHardObjectivesFulfilled()
+//                                              ))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//
+//              var modelElementInterpretation = model.getInterpretation(classModel);
+//              modelElementInterpretation.put(dseAdapter.createObject(), true);
+//              queryEngine.flushChanges();
+//
+//              var states = dseAdapter.explore();
+//              assertEquals(222, states.size());
+//      }
+//
+//      @Test
+//      void BeFSTrivialTest() {
+//              var store = ModelStore.builder()
+//                              .symbols(classModel)
+//                              .with(ViatraModelQueryAdapter.builder())
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .strategy(new BestFirstStrategy().withDepthLimit(0)))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//
+//              var states = dseAdapter.explore();
+//              assertEquals(1, states.size());
+//      }
+//
+//      @Test
+//      void BeFSOneRuleTest() {
+//              var createClassPrecondition = Query.of("CreateClassPrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createClassRule = new TransformationRule("CreateClass",
+//                              createClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var store = ModelStore.builder()
+//                              .symbols(classModel, classElement, classes)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(createClassPrecondition))
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .transformations(createClassRule)
+//                                              .strategy(new BestFirstStrategy().withDepthLimit(4)
+//                                              ))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//
+//              var modelElementInterpretation = model.getInterpretation(classModel);
+//              modelElementInterpretation.put(dseAdapter.createObject(), true);
+//              queryEngine.flushChanges();
+//
+//              var states = dseAdapter.explore();
+//              assertEquals(1, states.size());
+//      }
+//
+//      @Test
+//      void BeFSContinueTest() {
+//              var createClassPrecondition = Query.of("CreateClassPrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createClassRule = new TransformationRule("CreateClass",
+//                              createClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var store = ModelStore.builder()
+//                              .symbols(classModel, classElement, classes)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(createClassPrecondition))
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .transformations(createClassRule)
+//                                              .strategy(new BestFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
+//                                              ))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//
+//              var modelElementInterpretation = model.getInterpretation(classModel);
+//              modelElementInterpretation.put(dseAdapter.createObject(), true);
+//              queryEngine.flushChanges();
+//
+//              var states = dseAdapter.explore();
+//              assertEquals(5, states.size());
+//      }
+//
+//      @Test
+//      void BeFSCompletenessTest() {
+//              var createClassPrecondition = Query.of("CreateClassPrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createClassRule = new TransformationRule("CreateClass",
+//                              createClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createFeatureRule = new TransformationRule("CreateFeature",
+//                              createFeaturePrecondition,
+//                              (model) -> {
+//                                      var featuresInterpretation = model.getInterpretation(features);
+//                                      var featureInterpretation = model.getInterpretation(feature);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              featureInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var store = ModelStore.builder()
+//                              .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(createClassPrecondition, createFeaturePrecondition))
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .transformations(createClassRule, createFeatureRule)
+//                                              .strategy(new BestFirstStrategy().withDepthLimit(10).continueIfHardObjectivesFulfilled()
+//                                              ))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//
+//              var modelElementInterpretation = model.getInterpretation(classModel);
+//              modelElementInterpretation.put(dseAdapter.createObject(), true);
+//              queryEngine.flushChanges();
+//
+//              var states = dseAdapter.explore();
+//              assertEquals(2047, states.size());
+//      }
+//
+//      @Test
+//      void BeFSSolutionLimitTest() {
+//              var createClassPrecondition = Query.of("CreateClassPrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createClassRule = new TransformationRule("CreateClass",
+//                              createClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
+//                              (builder, model) -> builder.clause(
+//                                              classModelView.call(model)
+//                              ));
+//
+//              var createFeatureRule = new TransformationRule("CreateFeature",
+//                              createFeaturePrecondition,
+//                              (model) -> {
+//                                      var featuresInterpretation = model.getInterpretation(features);
+//                                      var featureInterpretation = model.getInterpretation(feature);
+//                                      return ((Tuple activation) -> {
+//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//                                              var modelElement = activation.get(0);
+//
+//                                              var newClassElement = dseAdapter.createObject();
+//                                              var newClassElementId = newClassElement.get(0);
+//
+//                                              featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
+//                                              featureInterpretation.put(Tuple.of(newClassElementId), true);
+//                                      });
+//                              });
+//
+//              var store = ModelStore.builder()
+//                              .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(createClassPrecondition, createFeaturePrecondition))
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .transformations(createClassRule, createFeatureRule)
+//                                              .strategy(new BestFirstStrategy().withSolutionLimit(222)
+//                                                              .continueIfHardObjectivesFulfilled()
+//                                              ))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//
+//              var modelElementInterpretation = model.getInterpretation(classModel);
+//              modelElementInterpretation.put(dseAdapter.createObject(), true);
+//              queryEngine.flushChanges();
+//
+//              var states = dseAdapter.explore();
+//              assertEquals(222, states.size());
+//      }
+
+}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java
new file mode 100644
index 00000000..43b04e0d
--- /dev/null
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java
@@ -0,0 +1,414 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse;
+
+import org.junit.jupiter.api.Test;
+//
+//import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
+//import tools.refinery.store.model.ModelStore;
+//import tools.refinery.store.query.ModelQueryAdapter;
+//import tools.refinery.store.query.dnf.Query;
+//import tools.refinery.store.dse.transition.TransformationRule;
+//import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
+//import tools.refinery.store.query.view.AnySymbolView;
+//import tools.refinery.store.query.view.KeyOnlyView;
+//import tools.refinery.store.representation.Symbol;
+//import tools.refinery.store.tuple.Tuple;
+//
+//import java.util.List;
+//import java.util.Map;
+//
+//import static org.junit.jupiter.api.Assertions.assertEquals;
+//import static tools.refinery.store.query.literal.Literals.not;
+//import static tools.refinery.store.dse.tests.QueryAssertions.assertResults;
+//
+class TransformationRuleTest {
+//
+//      private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
+//      private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1);
+//      private static final Symbol<Boolean> feature = Symbol.of("Feature", 1);
+//
+//      private static final Symbol<Boolean> isEncapsulatedBy = Symbol.of("IsEncapsulatedBy", 2);
+//      private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2);
+//
+//      private static final Symbol<Boolean> features = Symbol.of("Features", 2);
+//      private static final Symbol<Boolean> classes = Symbol.of("Classes", 2);
+//
+//      private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel);
+//      private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement);
+//      private static final AnySymbolView featureView = new KeyOnlyView<>(feature);
+//      private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
+//      private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
+//      private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
+//      private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
+//
+//      @Test
+//      void activationsTest() {
+//              var assignFeaturePreconditionHelper = Query.of("AssignFeaturePreconditionHelper",
+//                              (builder, model, c, f) -> builder.clause(
+//                                              classElementView.call(c),
+//                                              classesView.call(model, c),
+//                                              encapsulatesView.call(c, f)
+//                              ));
+//
+//              var assignFeaturePrecondition = Query.of("AssignFeaturePrecondition", (builder, c2, f)
+//                              -> builder.clause((model, c1) -> List.of(
+//                              classModelView.call(model),
+//                              featureView.call(f),
+//                              classElementView.call(c2),
+//                              featuresView.call(model, f),
+//                              classesView.call(model, c1),
+//                              not(assignFeaturePreconditionHelper.call(model, c2, f)),
+//                              not(encapsulatesView.call(c2, f))
+//              )));
+//
+//              var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
+//                              (builder, model, c) -> builder.clause((f) -> List.of(
+//                                              classModelView.call(model),
+//                                              classElementView.call(c),
+//                                              featuresView.call(model, f),
+//                                              not(encapsulatesView.call(c, f))
+//                              )));
+//
+//              TransformationRule assignFeatureRule = new TransformationRule("AssignFeature",
+//                              assignFeaturePrecondition,
+//                              (model) -> {
+//                                      var isEncapsulatedByInterpretation = model.getInterpretation(isEncapsulatedBy);
+//                                      return ((Tuple activation) -> {
+//                                              var feature = activation.get(0);
+//                                              var classElement = activation.get(1);
+//
+//                                              isEncapsulatedByInterpretation.put(Tuple.of(feature, classElement), true);
+//                                      });
+//                              });
+//
+//              TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass",
+//                              deleteEmptyClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var modelElement = activation.get(0);
+//                                              var classElement = activation.get(1);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, classElement), false);
+//                                              classElementInterpretation.put(Tuple.of(classElement), false);
+//                                      });
+//                              });
+//
+//
+//              var store = ModelStore.builder()
+//                              .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(assignFeaturePrecondition, assignFeaturePreconditionHelper,
+//                                                              deleteEmptyClassPrecondition))
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//              assignFeatureRule.prepare(model, queryEngine);
+//              deleteEmptyClassRule.prepare(model, queryEngine);
+//
+//              var classModelInterpretation = model.getInterpretation(classModel);
+//              var classElementInterpretation = model.getInterpretation(classElement);
+//              var featureInterpretation = model.getInterpretation(feature);
+//              var featuresInterpretation = model.getInterpretation(features);
+//              var classesInterpretation = model.getInterpretation(classes);
+//
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//              var newModel = dseAdapter.createObject();
+//              var newModelId = newModel.get(0);
+//              var newClass1 = dseAdapter.createObject();
+//              var newClass1Id = newClass1.get(0);
+//              var newClass2 = dseAdapter.createObject();
+//              var newClass2Id = newClass2.get(0);
+//              var newField = dseAdapter.createObject();
+//              var newFieldId = newField.get(0);
+//
+//              classModelInterpretation.put(newModel, true);
+//              classElementInterpretation.put(newClass1, true);
+//              classElementInterpretation.put(newClass2, true);
+//              featureInterpretation.put(newField, true);
+//              classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
+//              classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
+//              featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
+//
+//              queryEngine.flushChanges();
+//
+//              var assignFeatureRuleActivations = assignFeatureRule.getAllActivationsAsResultSet();
+//              var deleteEmptyClassRuleActivations = deleteEmptyClassRule.getAllActivationsAsResultSet();
+//
+//              assertResults(Map.of(
+//                              Tuple.of(newClass1Id, newFieldId), true,
+//                              Tuple.of(newClass2Id, newFieldId), true
+//              ), assignFeatureRuleActivations);
+//
+//              assertResults(Map.of(
+//                              Tuple.of(newModelId, newClass1Id), true,
+//                              Tuple.of(newModelId, newClass2Id), true
+//              ), deleteEmptyClassRuleActivations);
+//      }
+//
+//      @Test
+//      void randomActivationTest() {
+//              var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
+//                              (builder, model, c) -> builder.clause((f) -> List.of(
+//                                              classModelView.call(model),
+//                                              classElementView.call(c),
+//                                              featuresView.call(model, f),
+//                                              not(encapsulatesView.call(c, f))
+//                              )));
+//
+//              TransformationRule deleteEmptyClassRule0 = new TransformationRule("DeleteEmptyClass0",
+//                              deleteEmptyClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var modelElement = activation.get(0);
+//                                              var classElement = activation.get(1);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, classElement), false);
+//                                              classElementInterpretation.put(Tuple.of(classElement), false);
+//                                      });
+//                              },
+//                              0L);
+//
+//              TransformationRule deleteEmptyClassRule1 = new TransformationRule("DeleteEmptyClass1",
+//                              deleteEmptyClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var modelElement = activation.get(0);
+//                                              var classElement = activation.get(1);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, classElement), false);
+//                                              classElementInterpretation.put(Tuple.of(classElement), false);
+//                                      });
+//                              },
+//                              78634L);
+//
+//              var store = ModelStore.builder()
+//                              .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(deleteEmptyClassPrecondition))
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//              deleteEmptyClassRule0.prepare(model, queryEngine);
+//              deleteEmptyClassRule1.prepare(model, queryEngine);
+//
+//              var classModelInterpretation = model.getInterpretation(classModel);
+//              var classElementInterpretation = model.getInterpretation(classElement);
+//              var featureInterpretation = model.getInterpretation(feature);
+//              var featuresInterpretation = model.getInterpretation(features);
+//              var classesInterpretation = model.getInterpretation(classes);
+//
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//              var newModel = dseAdapter.createObject();
+//              var newModelId = newModel.get(0);
+//              var newClass1 = dseAdapter.createObject();
+//              var newClass1Id = newClass1.get(0);
+//              var newClass2 = dseAdapter.createObject();
+//              var newClass2Id = newClass2.get(0);
+//              var newField = dseAdapter.createObject();
+//              var newFieldId = newField.get(0);
+//
+//              classModelInterpretation.put(newModel, true);
+//              classElementInterpretation.put(newClass1, true);
+//              classElementInterpretation.put(newClass2, true);
+//              featureInterpretation.put(newField, true);
+//              classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
+//              classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
+//              featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
+//
+//              queryEngine.flushChanges();
+//
+//
+//              var activation0 = deleteEmptyClassRule0.getRandomActivation().activation();
+//              var activation1 = deleteEmptyClassRule1.getRandomActivation().activation();
+//
+//              assertResults(Map.of(
+//                              Tuple.of(newModelId, newClass1Id), true,
+//                              Tuple.of(newModelId, newClass2Id), true
+//              ), deleteEmptyClassRule0.getAllActivationsAsResultSet());
+//
+//              assertResults(Map.of(
+//                              Tuple.of(newModelId, newClass1Id), true,
+//                              Tuple.of(newModelId, newClass2Id), true
+//              ), deleteEmptyClassRule1.getAllActivationsAsResultSet());
+//
+//              assertEquals(Tuple.of(newModelId, newClass2Id), activation0);
+//              assertEquals(Tuple.of(newModelId, newClass1Id), activation1);
+//
+//      }
+//
+//      @Test
+//      void fireTest() {
+//              var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
+//                              (builder, model, c) -> builder.clause((f) -> List.of(
+//                                              classModelView.call(model),
+//                                              classElementView.call(c),
+//                                              featuresView.call(model, f),
+//                                              not(encapsulatesView.call(c, f))
+//                              )));
+//
+//              TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass",
+//                              deleteEmptyClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var modelElement = activation.get(0);
+//                                              var classElement = activation.get(1);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, classElement), false);
+//                                              classElementInterpretation.put(Tuple.of(classElement), false);
+//                                      });
+//                              });
+//
+//              var store = ModelStore.builder()
+//                              .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(deleteEmptyClassPrecondition))
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//              deleteEmptyClassRule.prepare(model, queryEngine);
+//
+//              var classModelInterpretation = model.getInterpretation(classModel);
+//              var classElementInterpretation = model.getInterpretation(classElement);
+//              var featureInterpretation = model.getInterpretation(feature);
+//              var featuresInterpretation = model.getInterpretation(features);
+//              var classesInterpretation = model.getInterpretation(classes);
+//
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//              var newModel = dseAdapter.createObject();
+//              var newModelId = newModel.get(0);
+//              var newClass1 = dseAdapter.createObject();
+//              var newClass1Id = newClass1.get(0);
+//              var newClass2 = dseAdapter.createObject();
+//              var newClass2Id = newClass2.get(0);
+//              var newField = dseAdapter.createObject();
+//              var newFieldId = newField.get(0);
+//
+//              classModelInterpretation.put(newModel, true);
+//              classElementInterpretation.put(newClass1, true);
+//              classElementInterpretation.put(newClass2, true);
+//              featureInterpretation.put(newField, true);
+//              classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
+//              classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
+//              featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
+//
+//              queryEngine.flushChanges();
+//
+//              assertResults(Map.of(
+//                              Tuple.of(newModelId, newClass1Id), true,
+//                              Tuple.of(newModelId, newClass2Id), true
+//              ), deleteEmptyClassRule.getAllActivationsAsResultSet());
+//
+//
+//              deleteEmptyClassRule.fireActivation(Tuple.of(0, 1));
+//
+//              assertResults(Map.of(
+//                              Tuple.of(newModelId, newClass1Id), false,
+//                              Tuple.of(newModelId, newClass2Id), true
+//              ), deleteEmptyClassRule.getAllActivationsAsResultSet());
+//      }
+//
+//      @Test
+//      void randomFireTest() {
+//              var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
+//                              (builder, model, c) -> builder.clause((f) -> List.of(
+//                                              classModelView.call(model),
+//                                              classElementView.call(c),
+//                                              featuresView.call(model, f),
+//                                              not(encapsulatesView.call(c, f))
+//                              )));
+//
+//              TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass0",
+//                              deleteEmptyClassPrecondition,
+//                              (model) -> {
+//                                      var classesInterpretation = model.getInterpretation(classes);
+//                                      var classElementInterpretation = model.getInterpretation(classElement);
+//                                      return ((Tuple activation) -> {
+//                                              var modelElement = activation.get(0);
+//                                              var classElement = activation.get(1);
+//
+//                                              classesInterpretation.put(Tuple.of(modelElement, classElement), false);
+//                                              classElementInterpretation.put(Tuple.of(classElement), false);
+//                                      });
+//                              },
+//                              0L);
+//
+//              var store = ModelStore.builder()
+//                              .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
+//                              .with(ViatraModelQueryAdapter.builder()
+//                                              .queries(deleteEmptyClassPrecondition))
+//                              .with(DesignSpaceExplorationAdapter.builder()
+//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)))
+//                              .build();
+//
+//              var model = store.createEmptyModel();
+//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+//              deleteEmptyClassRule.prepare(model, queryEngine);
+//
+//              var classModelInterpretation = model.getInterpretation(classModel);
+//              var classElementInterpretation = model.getInterpretation(classElement);
+//              var featureInterpretation = model.getInterpretation(feature);
+//              var featuresInterpretation = model.getInterpretation(features);
+//              var classesInterpretation = model.getInterpretation(classes);
+//
+//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+//              var newModel = dseAdapter.createObject();
+//              var newModelId = newModel.get(0);
+//              var newClass1 = dseAdapter.createObject();
+//              var newClass1Id = newClass1.get(0);
+//              var newClass2 = dseAdapter.createObject();
+//              var newClass2Id = newClass2.get(0);
+//              var newField = dseAdapter.createObject();
+//              var newFieldId = newField.get(0);
+//
+//              classModelInterpretation.put(newModel, true);
+//              classElementInterpretation.put(newClass1, true);
+//              classElementInterpretation.put(newClass2, true);
+//              featureInterpretation.put(newField, true);
+//              classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
+//              classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
+//              featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
+//
+//              queryEngine.flushChanges();
+//
+//              assertResults(Map.of(
+//                              Tuple.of(newModelId, newClass1Id), true,
+//                              Tuple.of(newModelId, newClass2Id), true
+//              ), deleteEmptyClassRule.getAllActivationsAsResultSet());
+//
+//              deleteEmptyClassRule.fireRandomActivation();
+//
+//              assertResults(Map.of(
+//                              Tuple.of(newModelId, newClass1Id), true,
+//                              Tuple.of(newModelId, newClass2Id), false
+//              ), deleteEmptyClassRule.getAllActivationsAsResultSet());
+//
+//              deleteEmptyClassRule.fireRandomActivation();
+//
+//              assertResults(Map.of(
+//                              Tuple.of(newModelId, newClass1Id), false,
+//                              Tuple.of(newModelId, newClass2Id), false
+//              ), deleteEmptyClassRule.getAllActivationsAsResultSet());
+//
+//      }
+}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/QueryAssertions.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/QueryAssertions.java
new file mode 100644
index 00000000..f0a20720
--- /dev/null
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/QueryAssertions.java
@@ -0,0 +1,57 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.tests;
+
+import org.junit.jupiter.api.function.Executable;
+import tools.refinery.store.query.resultset.ResultSet;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.*;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.nullValue;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+public final class QueryAssertions {
+        private QueryAssertions() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static <T> void assertNullableResults(Map<Tuple, Optional<T>> expected, ResultSet<T> resultSet) {
+                var nullableValuesMap = new LinkedHashMap<Tuple, T>(expected.size());
+                for (var entry : expected.entrySet()) {
+                        nullableValuesMap.put(entry.getKey(), entry.getValue().orElse(null));
+                }
+                assertResults(nullableValuesMap, resultSet);
+        }
+
+        public static <T> void assertResults(Map<Tuple, T> expected, ResultSet<T> resultSet) {
+                var defaultValue = resultSet.getCanonicalQuery().defaultValue();
+                var filteredExpected = new LinkedHashMap<Tuple, T>();
+                var executables = new ArrayList<Executable>();
+                for (var entry : expected.entrySet()) {
+                        var key = entry.getKey();
+                        var value = entry.getValue();
+                        if (!Objects.equals(value, defaultValue)) {
+                                filteredExpected.put(key, value);
+                        }
+                        executables.add(() -> assertThat("value for key " + key,resultSet.get(key), is(value)));
+                }
+                executables.add(() -> assertThat("results size", resultSet.size(), is(filteredExpected.size())));
+
+                var actual = new LinkedHashMap<Tuple, T>();
+                var cursor = resultSet.getAll();
+                while (cursor.move()) {
+                        var key = cursor.getKey();
+                        var previous = actual.put(key, cursor.getValue());
+                        assertThat("duplicate value for key " + key, previous, nullValue());
+                }
+                executables.add(() -> assertThat("results cursor", actual, is(filteredExpected)));
+
+                assertAll(executables);
+        }
+}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/transition/statespace/internal/ActivationUnitTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/transition/statespace/internal/ActivationUnitTest.java
new file mode 100644
index 00000000..e7960a06
--- /dev/null
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/transition/statespace/internal/ActivationUnitTest.java
@@ -0,0 +1,72 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.statespace.internal;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.stream.Stream;
+
+class ActivationUnitTest {
+        private final static int SMALL_SIZE = 5;
+
+        private static Stream<ActivationStoreEntry> entries() {
+                return Stream.of(
+                                new ActivationStoreBitVectorEntry(SMALL_SIZE),
+                                new ActivationStoreListEntry(SMALL_SIZE));
+        }
+
+        void addTest(ActivationStoreEntry entry, int elementsAdded) {
+                Assertions.assertEquals(elementsAdded,entry.getNumberOfVisitedActivations());
+                Assertions.assertEquals(SMALL_SIZE-elementsAdded,entry.getNumberOfUnvisitedActivations());
+        }
+
+        @ParameterizedTest
+        @MethodSource("entries")
+        void testDifferent(ActivationStoreEntry entry) {
+                int elementsAdded = 0;
+                addTest(entry,elementsAdded);
+                Assertions.assertEquals(2, entry.getAndAddActivationAfter(2));
+                addTest(entry,++elementsAdded);
+                Assertions.assertEquals(3,entry.getAndAddActivationAfter(3));
+                addTest(entry,++elementsAdded);
+                Assertions.assertEquals(1,entry.getAndAddActivationAfter(1));
+                addTest(entry,++elementsAdded);
+                Assertions.assertEquals(4,entry.getAndAddActivationAfter(4));
+                addTest(entry,++elementsAdded);
+                Assertions.assertEquals(0,entry.getAndAddActivationAfter(0));
+                addTest(entry,++elementsAdded);
+        }
+
+        @ParameterizedTest
+        @MethodSource("entries")
+        void testSame(ActivationStoreEntry entry) {
+                int elementsAdded = 0;
+                addTest(entry,elementsAdded);
+                entry.getAndAddActivationAfter(2);
+                addTest(entry,++elementsAdded);
+                entry.getAndAddActivationAfter(2);
+                addTest(entry,++elementsAdded);
+                entry.getAndAddActivationAfter(2);
+                addTest(entry,++elementsAdded);
+                entry.getAndAddActivationAfter(2);
+                addTest(entry,++elementsAdded);
+                entry.getAndAddActivationAfter(2);
+                addTest(entry,++elementsAdded);
+        }
+
+        @ParameterizedTest
+        @MethodSource("entries")
+        void testFilling(ActivationStoreEntry entry) {
+                int elementsAdded = 0;
+                while(elementsAdded < SMALL_SIZE) {
+                        entry.getAndAddActivationAfter(2);
+                        elementsAdded++;
+                }
+                Assertions.assertThrows(IllegalArgumentException.class,()-> entry.getAndAddActivationAfter(2));
+        }
+}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java
index 5a484119..3f8c060a 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java
@@ -6,7 +6,6 @@
 package tools.refinery.store.query.viatra;
 
 import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.ModelQueryAdapter;
@@ -283,7 +282,6 @@ class QueryTransactionTest {
                 assertResults(Map.of(Tuple.of(0), false), queryResultSet);
         }
 
-        @Disabled("TODO Fix DiffCursor")
         @Test
         void commitAfterFlushTest() {
                 var store = ModelStore.builder()
@@ -332,7 +330,6 @@ class QueryTransactionTest {
                 ), predicateResultSet);
         }
 
-        @Disabled("TODO Fix DiffCursor")
         @Test
         void commitWithoutFlushTest() {
                 var store = ModelStore.builder()
diff --git a/subprojects/store/src/jmh/java/tools/refinery/store/map/benchmarks/ImmutablePutExecutionPlan.java b/subprojects/store/src/jmh/java/tools/refinery/store/map/benchmarks/ImmutablePutExecutionPlan.java
index edd4f53e..4708e6d3 100644
--- a/subprojects/store/src/jmh/java/tools/refinery/store/map/benchmarks/ImmutablePutExecutionPlan.java
+++ b/subprojects/store/src/jmh/java/tools/refinery/store/map/benchmarks/ImmutablePutExecutionPlan.java
@@ -5,12 +5,13 @@
  */
 package tools.refinery.store.map.benchmarks;
 
+import java.util.Objects;
 import java.util.Random;
 
-import tools.refinery.store.map.ContinousHashProvider;
+import tools.refinery.store.map.ContinuousHashProvider;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.internal.state.VersionedMapStoreStateImpl;
+import tools.refinery.store.map.internal.state.VersionedMapStateImpl;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 import org.openjdk.jmh.annotations.Level;
@@ -35,17 +36,17 @@ public class ImmutablePutExecutionPlan {
 
         private String[] values;
 
-        private ContinousHashProvider<Integer> hashProvider = MapTestEnvironment.prepareHashProvider(false);
+        private ContinuousHashProvider<Integer> hashProvider = MapTestEnvironment.prepareHashProvider(false);
 
         @Setup(Level.Trial)
         public void setUpTrial() {
                 random = new Random();
-                values = MapTestEnvironment.prepareValues(nValues);
+                values = MapTestEnvironment.prepareValues(nValues, true);
         }
 
-        public VersionedMapImpl<Integer, String> createSut() {
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(hashProvider, values[0]);
-                return (VersionedMapImpl<Integer, String>) store.createMap();
+        public VersionedMapStateImpl<Integer, String> createSut() {
+                VersionedMapStore<Integer, String> store = new VersionedMapStoreStateImpl<>(hashProvider, values[0]);
+                return (VersionedMapStateImpl<Integer, String>) store.createMap();
         }
 
         public Integer nextKey() {
@@ -53,7 +54,7 @@ public class ImmutablePutExecutionPlan {
         }
 
         public boolean isDefault(String value) {
-                return value == values[0];
+                return Objects.equals(value,values[0]);
         }
 
         public String nextValue() {
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/AnyVersionedMap.java b/subprojects/store/src/main/java/tools/refinery/store/map/AnyVersionedMap.java
index 25fc91e6..01099eb0 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/AnyVersionedMap.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/AnyVersionedMap.java
@@ -42,4 +42,9 @@ public sealed interface AnyVersionedMap extends Versioned permits VersionedMap {
         @SuppressWarnings("squid:S1133")
         @Deprecated(since = "0.0.0")
         boolean equals(Object obj);
+
+        /**
+         * Checks the integrity of the map, and throws an exception if an inconsistency is detected.
+         */
+        void checkIntegrity();
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/ContinousHashProvider.java b/subprojects/store/src/main/java/tools/refinery/store/map/ContinuousHashProvider.java
index 8e451230..abc044d0 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/ContinousHashProvider.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/ContinuousHashProvider.java
@@ -5,17 +5,17 @@
  */
 package tools.refinery.store.map;
 
-import tools.refinery.store.map.internal.Node;
+import tools.refinery.store.map.internal.state.Node;
 
 /**
  * A class representing an equivalence relation for a type {@code K} with a
  * continuous hash function.
- * 
+ *
  * @author Oszkar Semerath
  *
  * @param <K> Target java type.
  */
-public interface ContinousHashProvider<K> {
+public interface ContinuousHashProvider<K> {
         public static final int EFFECTIVE_BITS = Node.EFFECTIVE_BITS;
         public static final int EFFECTIVE_BIT_MASK = (1 << (EFFECTIVE_BITS)) - 1;
 
@@ -38,9 +38,9 @@ public interface ContinousHashProvider<K> {
          * {@link #EFFECTIVE_BITS}
          * </ul>
          * Check {@link #equals} for further details.
-         * 
+         *
          * @param key   The target data object.
-         * @param index The depth of the the hash code. Needs to be non-negative.
+         * @param index The depth of the hash code. Needs to be non-negative.
          * @return A hash code.
          */
         public int getHash(K key, int index);
@@ -53,7 +53,7 @@ public interface ContinousHashProvider<K> {
                 if (key1.equals(key2)) {
                         return 0;
                 } else {
-                        for (int i = 0; i < ContinousHashProvider.MAX_PRACTICAL_DEPTH; i++) {
+                        for (int i = 0; i < ContinuousHashProvider.MAX_PRACTICAL_DEPTH; i++) {
                                 int hash1 = getEffectiveHash(key1, i);
                                 int hash2 = getEffectiveHash(key2, i);
                                 for(int j = 0; j<Integer.SIZE/Node.BRANCHING_FACTOR_BITS; j++) {
@@ -68,7 +68,7 @@ public interface ContinousHashProvider<K> {
                         }
                         throw new IllegalArgumentException("Two different keys (" + key1 + " and " + key2
                                         + ") have the same hashcode over the practical depth limitation ("
-                                        + ContinousHashProvider.MAX_PRACTICAL_DEPTH + ")!");
+                                        + ContinuousHashProvider.MAX_PRACTICAL_DEPTH + ")!");
                 }
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/IteratorAsCursor.java b/subprojects/store/src/main/java/tools/refinery/store/map/IteratorAsCursor.java
new file mode 100644
index 00000000..29b03edf
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/IteratorAsCursor.java
@@ -0,0 +1,64 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+public class IteratorAsCursor<K, V> implements Cursor<K, V> {
+        final Iterator<Entry<K, V>> iterator;
+        final VersionedMap<K, V> source;
+
+        private boolean terminated;
+        private K key;
+        private V value;
+
+        public IteratorAsCursor(VersionedMap<K, V> source, Map<K, V> current) {
+                this.iterator = current.entrySet().iterator();
+                this.source = source;
+        }
+
+        @Override
+        public K getKey() {
+                return key;
+        }
+
+        @Override
+        public V getValue() {
+                return value;
+        }
+
+        @Override
+        public boolean isTerminated() {
+                return terminated;
+        }
+
+        @Override
+        public boolean move() {
+                terminated = !iterator.hasNext();
+                if (terminated) {
+                        this.key = null;
+                        this.value = null;
+                } else {
+                        Entry<K, V> next = iterator.next();
+                        this.key = next.getKey();
+                        this.value = next.getValue();
+                }
+                return !terminated;
+        }
+
+        @Override
+        public boolean isDirty() {
+                return false;
+        }
+
+        @Override
+        public Set<AnyVersionedMap> getDependingMaps() {
+                return Set.of(this.source);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/Version.java b/subprojects/store/src/main/java/tools/refinery/store/map/Version.java
new file mode 100644
index 00000000..fa2734e4
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/Version.java
@@ -0,0 +1,26 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map;
+
+/**
+ * Interface denoting versions of {@link Versioned}.
+ */
+public interface Version {
+        /**
+         * Hashcode should be updated in accordance with equals.
+         * @return a hashcode of the object.
+         */
+        int hashCode();
+
+        /**
+         * Equivalence of two {@link Version}. This equivalence must satisfy the following constraint (in addition to the
+         * constraints of {@link Object#equals(Object)}: if {@code v1} and {@code v2} are {@link Version}s, and {@code v1
+         * .equals(v2)}, then {@code versioned.restore(v1)} must be {@code equals} to {@code versioned.restore(v2)}.
+         * @param o the other object.
+         * @return weather the two versions are equals.
+         */
+        boolean equals(Object o);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/Versioned.java b/subprojects/store/src/main/java/tools/refinery/store/map/Versioned.java
index 55720db3..da12b0a9 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/Versioned.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/Versioned.java
@@ -5,8 +5,20 @@
  */
 package tools.refinery.store.map;
 
+/**
+ * Object that can save and restore its state.
+ */
 public interface Versioned {
-        public long commit();
-        //maybe revert()?
-        public void restore(long state);
+        /**
+         * Saves the state of the object.
+         * @return an object that marks the version of the object at the time the function was called.
+         */
+        Version commit();
+
+        /**
+         * Restores the state of the object.
+         * @param state a {@link Version} object that marks the version. The state must be a {@link Version} object
+         *                 returned by a previous {@link #commit()}!
+         */
+        void restore(Version state);
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMap.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMap.java
index 9bbde24d..28194b58 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMap.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMap.java
@@ -6,6 +6,8 @@
 package tools.refinery.store.map;
 
 public non-sealed interface VersionedMap<K, V> extends AnyVersionedMap {
+        V getDefaultValue();
+
         V get(K key);
 
         Cursor<K, V> getAll();
@@ -14,5 +16,5 @@ public non-sealed interface VersionedMap<K, V> extends AnyVersionedMap {
 
         void putAll(Cursor<K, V> cursor);
 
-        DiffCursor<K, V> getDiffCursor(long state);
+        DiffCursor<K, V> getDiffCursor(Version state);
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStore.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStore.java
index 5aafa338..55cf08a5 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStore.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStore.java
@@ -5,15 +5,17 @@
  */
 package tools.refinery.store.map;
 
-import java.util.Set;
+import tools.refinery.store.map.internal.VersionedMapStoreFactoryBuilderImpl;
 
 public interface VersionedMapStore<K, V> {
-        
-        public VersionedMap<K, V> createMap();
 
-        public VersionedMap<K, V> createMap(long state);
-        
-        public Set<Long> getStates();
+        VersionedMap<K, V> createMap();
 
-        public DiffCursor<K,V> getDiffCursor(long fromState, long toState);
-}
\ No newline at end of file
+        VersionedMap<K, V> createMap(Version state);
+
+        DiffCursor<K,V> getDiffCursor(Version fromState, Version toState);
+
+        static <K,V> VersionedMapStoreFactoryBuilder<K,V> builder() {
+                return new VersionedMapStoreFactoryBuilderImpl<>();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactory.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactory.java
new file mode 100644
index 00000000..baf6ab50
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactory.java
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map;
+
+import java.util.List;
+
+public interface VersionedMapStoreFactory<K,V> {
+        /**
+         * Constructs a new instance of {@link VersionedMap}.
+         * @return The new instance.
+         */
+        VersionedMapStore<K,V> createOne();
+
+        /**
+         * Constructs a group of {@link VersionedMap}s with the same configuration. If possible, the stores share
+         * resources with each other.
+         * @param amount The amount of new instances to be created.
+         * @return A list of new stores with the given number of elements.
+         */
+        List<VersionedMapStore<K, V>> createGroup(int amount);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactoryBuilder.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactoryBuilder.java
new file mode 100644
index 00000000..0ac196f2
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactoryBuilder.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map;
+
+public interface VersionedMapStoreFactoryBuilder<K,V> {
+        enum StoreStrategy {
+                STATE, DELTA
+        }
+
+        enum DeltaTransactionStrategy {
+                LIST, SET
+        }
+
+        enum SharingStrategy {
+                NO_NODE_CACHE, SHARED_NODE_CACHE, SHARED_NODE_CACHE_IN_GROUP
+        }
+
+        VersionedMapStoreFactoryBuilder<K,V> defaultValue(V defaultValue);
+        VersionedMapStoreFactoryBuilder<K,V> strategy(StoreStrategy strategy);
+        VersionedMapStoreFactoryBuilder<K,V> versionFreeing(boolean enabled);
+        VersionedMapStoreFactoryBuilder<K,V> stateBasedImmutableWhenCommitting(boolean transformToImmutable);
+        VersionedMapStoreFactoryBuilder<K,V> stateBasedSharingStrategy(SharingStrategy sharingStrategy);
+        VersionedMapStoreFactoryBuilder<K,V> stateBasedHashProvider(ContinuousHashProvider<K> hashProvider);
+        VersionedMapStoreFactoryBuilder<K,V> deltaTransactionStrategy(DeltaTransactionStrategy deltaStrategy);
+
+        VersionedMapStoreFactory<K,V> build();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreImpl.java
deleted file mode 100644
index aade4aeb..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreImpl.java
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.map;
-
-import tools.refinery.store.map.internal.ImmutableNode;
-import tools.refinery.store.map.internal.MapDiffCursor;
-import tools.refinery.store.map.internal.Node;
-import tools.refinery.store.map.internal.VersionedMapImpl;
-
-import java.util.*;
-
-public class VersionedMapStoreImpl<K, V> implements VersionedMapStore<K, V> {
-        // Configuration
-        private final boolean immutableWhenCommitting;
-
-        // Static data
-        protected final ContinousHashProvider<K> hashProvider;
-        protected final V defaultValue;
-
-        // Dynamic data
-        protected final Map<Long, ImmutableNode<K, V>> states = new HashMap<>();
-        protected final Map<Node<K, V>, ImmutableNode<K, V>> nodeCache;
-        protected long nextID = 0;
-
-        public VersionedMapStoreImpl(ContinousHashProvider<K> hashProvider, V defaultValue,
-                        VersionedMapStoreConfiguration config) {
-                this.immutableWhenCommitting = config.isImmutableWhenCommitting();
-                this.hashProvider = hashProvider;
-                this.defaultValue = defaultValue;
-                if (config.isSharedNodeCacheInStore()) {
-                        nodeCache = new HashMap<>();
-                } else {
-                        nodeCache = null;
-                }
-        }
-
-        private VersionedMapStoreImpl(ContinousHashProvider<K> hashProvider, V defaultValue,
-                        Map<Node<K, V>, ImmutableNode<K, V>> nodeCache, VersionedMapStoreConfiguration config) {
-                this.immutableWhenCommitting = config.isImmutableWhenCommitting();
-                this.hashProvider = hashProvider;
-                this.defaultValue = defaultValue;
-                this.nodeCache = nodeCache;
-        }
-
-        public VersionedMapStoreImpl(ContinousHashProvider<K> hashProvider, V defaultValue) {
-                this(hashProvider, defaultValue, new VersionedMapStoreConfiguration());
-        }
-
-        public static <K, V> List<VersionedMapStore<K, V>> createSharedVersionedMapStores(int amount,
-                        ContinousHashProvider<K> hashProvider, V defaultValue,
-                        VersionedMapStoreConfiguration config) {
-                List<VersionedMapStore<K, V>> result = new ArrayList<>(amount);
-                if (config.isSharedNodeCacheInStoreGroups()) {
-                        Map<Node<K, V>, ImmutableNode<K, V>> nodeCache;
-                        if (config.isSharedNodeCacheInStore()) {
-                                nodeCache = new HashMap<>();
-                        } else {
-                                nodeCache = null;
-                        }
-                        for (int i = 0; i < amount; i++) {
-                                result.add(new VersionedMapStoreImpl<>(hashProvider, defaultValue, nodeCache, config));
-                        }
-                } else {
-                        for (int i = 0; i < amount; i++) {
-                                result.add(new VersionedMapStoreImpl<>(hashProvider, defaultValue, config));
-                        }
-                }
-                return result;
-        }
-
-        public static <K, V> List<VersionedMapStore<K, V>> createSharedVersionedMapStores(int amount,
-                        ContinousHashProvider<K> hashProvider, V defaultValue) {
-                return createSharedVersionedMapStores(amount, hashProvider, defaultValue, new VersionedMapStoreConfiguration());
-        }
-
-        @Override
-        public synchronized Set<Long> getStates() {
-                return new HashSet<>(states.keySet());
-        }
-
-        @Override
-        public VersionedMap<K, V> createMap() {
-                return new VersionedMapImpl<>(this, hashProvider, defaultValue);
-        }
-
-        @Override
-        public VersionedMap<K, V> createMap(long state) {
-                ImmutableNode<K, V> data = revert(state);
-                return new VersionedMapImpl<>(this, hashProvider, defaultValue, data);
-        }
-
-        public synchronized ImmutableNode<K, V> revert(long state) {
-                if (states.containsKey(state)) {
-                        return states.get(state);
-                } else {
-                        ArrayList<Long> existingKeys = new ArrayList<>(states.keySet());
-                        Collections.sort(existingKeys);
-                        throw new IllegalArgumentException("Store does not contain state " + state + "! Avaliable states: "
-                                        + Arrays.toString(existingKeys.toArray()));
-                }
-        }
-
-        public synchronized long commit(Node<K, V> data, VersionedMapImpl<K, V> mapToUpdateRoot) {
-                ImmutableNode<K, V> immutable;
-                if (data != null) {
-                        immutable = data.toImmutable(this.nodeCache);
-                } else {
-                        immutable = null;
-                }
-
-                if (nextID == Long.MAX_VALUE)
-                        throw new IllegalStateException("Map store run out of Id-s");
-                long id = nextID++;
-                this.states.put(id, immutable);
-                if (this.immutableWhenCommitting) {
-                        mapToUpdateRoot.setRoot(immutable);
-                }
-                return id;
-        }
-
-        @Override
-        public DiffCursor<K, V> getDiffCursor(long fromState, long toState) {
-                VersionedMap<K, V> map1 = createMap(fromState);
-                VersionedMap<K, V> map2 = createMap(toState);
-                Cursor<K, V> cursor1 = map1.getAll();
-                Cursor<K, V> cursor2 = map2.getAll();
-                return new MapDiffCursor<>(this.hashProvider, this.defaultValue, cursor1, cursor2);
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/HashClash.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/HashClash.java
deleted file mode 100644
index 61b3d1b8..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/HashClash.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.map.internal;
-
-enum HashClash {
-        /**
-         * Not stuck.
-         */
-        NONE,
-        
-        /**
-         * Clashed, next we should return the key of cursor 1.
-         */
-        STUCK_CURSOR_1,
-        
-        /**
-         * Clashed, next we should return the key of cursor 2.
-         */
-        STUCK_CURSOR_2
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapDiffCursor.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapDiffCursor.java
deleted file mode 100644
index d31f1a05..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapDiffCursor.java
+++ /dev/null
@@ -1,229 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.map.internal;
-
-import tools.refinery.store.map.AnyVersionedMap;
-import tools.refinery.store.map.ContinousHashProvider;
-import tools.refinery.store.map.Cursor;
-import tools.refinery.store.map.DiffCursor;
-
-import java.util.Set;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-/**
- * A cursor representing the difference between two states of a map.
- *
- * @author Oszkar Semerath
- *
- */
-public class MapDiffCursor<K, V> implements DiffCursor<K, V>, Cursor<K, V> {
-        /**
-         * Default nodeId representing missing elements.
-         */
-        private final V defaultValue;
-        private final MapCursor<K, V> cursor1;
-        private final MapCursor<K, V> cursor2;
-        private final ContinousHashProvider<? super K> hashProvider;
-
-        // Values
-        private K key;
-        private V fromValue;
-        private V toValue;
-
-        // State
-        /**
-         * Positive number if cursor 1 is behind, negative number if cursor 2 is behind,
-         * and 0 if they are at the same position.
-         */
-        private int cursorRelation;
-        private HashClash hashClash = HashClash.NONE;
-
-        public MapDiffCursor(ContinousHashProvider<? super K> hashProvider, V defaultValue, Cursor<K, V> cursor1,
-                        Cursor<K, V> cursor2) {
-                super();
-                this.hashProvider = hashProvider;
-                this.defaultValue = defaultValue;
-                this.cursor1 = (MapCursor<K, V>) cursor1;
-                this.cursor2 = (MapCursor<K, V>) cursor2;
-        }
-
-        @Override
-        public K getKey() {
-                return key;
-        }
-
-        @Override
-        public V getFromValue() {
-                return fromValue;
-        }
-
-        @Override
-        public V getToValue() {
-                return toValue;
-        }
-
-        @Override
-        public V getValue() {
-                return getToValue();
-        }
-
-        public boolean isTerminated() {
-                return cursor1.isTerminated() && cursor2.isTerminated();
-        }
-
-        @Override
-        public boolean isDirty() {
-                return this.cursor1.isDirty() || this.cursor2.isDirty();
-        }
-
-        @Override
-        public Set<AnyVersionedMap> getDependingMaps() {
-                return Stream.concat(cursor1.getDependingMaps().stream(), cursor2.getDependingMaps().stream())
-                                .map(AnyVersionedMap.class::cast)
-                                .collect(Collectors.toUnmodifiableSet());
-        }
-
-        protected void updateState() {
-                if (!isTerminated()) {
-                        this.cursorRelation = MapCursor.compare(cursor1, cursor2);
-                        if (cursorRelation > 0 || cursor2.isTerminated()) {
-                                this.key = cursor1.getKey();
-                                this.fromValue = cursor1.getValue();
-                                this.toValue = defaultValue;
-                        } else if (cursorRelation < 0 || cursor1.isTerminated()) {
-                                this.key = cursor2.getKey();
-                                this.fromValue = defaultValue;
-                                this.toValue = cursor1.getValue();
-                        } else {
-                                // cursor1 = cursor2
-                                if (cursor1.getKey().equals(cursor2.getKey())) {
-                                        this.key = cursor1.getKey();
-                                        this.fromValue = cursor1.getValue();
-                                        this.toValue = defaultValue;
-                                } else {
-                                        resolveHashClashWithFirstEntry();
-                                }
-                        }
-                }
-        }
-
-        protected void resolveHashClashWithFirstEntry() {
-                int compareResult = this.hashProvider.compare(cursor1.key, cursor2.key);
-                if (compareResult < 0) {
-                        this.hashClash = HashClash.STUCK_CURSOR_2;
-                        this.cursorRelation = 0;
-                        this.key = cursor1.key;
-                        this.fromValue = cursor1.value;
-                        this.toValue = defaultValue;
-                } else if (compareResult > 0) {
-                        this.hashClash = HashClash.STUCK_CURSOR_1;
-                        this.cursorRelation = 0;
-                        this.key = cursor2.key;
-                        this.fromValue = defaultValue;
-                        this.toValue = cursor2.value;
-                } else {
-                        throw new IllegalArgumentException("Inconsistent compare result for diffcursor");
-                }
-        }
-
-        protected boolean isInHashClash() {
-                return this.hashClash != HashClash.NONE;
-        }
-
-        protected void resolveHashClashWithSecondEntry() {
-                switch (this.hashClash) {
-                case STUCK_CURSOR_1:
-                        this.hashClash = HashClash.NONE;
-                        this.cursorRelation = 0;
-                        this.key = cursor1.key;
-                        this.fromValue = cursor1.value;
-                        this.toValue = defaultValue;
-                        break;
-                case STUCK_CURSOR_2:
-                        this.hashClash = HashClash.NONE;
-                        this.cursorRelation = 0;
-                        this.key = cursor2.key;
-                        this.fromValue = defaultValue;
-                        this.toValue = cursor2.value;
-                        break;
-                default:
-                        throw new IllegalArgumentException("Inconsistent compare result for diffcursor");
-                }
-        }
-
-        protected boolean sameValues() {
-                if (this.fromValue == null) {
-                        return this.toValue == null;
-                } else {
-                        return this.fromValue.equals(this.toValue);
-                }
-        }
-
-        protected boolean moveOne() {
-                if (isTerminated()) {
-                        return false;
-                }
-                if (this.cursorRelation > 0 || cursor2.isTerminated()) {
-                        return cursor1.move();
-                } else if (this.cursorRelation < 0 || cursor1.isTerminated()) {
-                        return cursor2.move();
-                } else {
-                        boolean moved1 = cursor1.move();
-                        boolean moved2 = cursor2.move();
-                        return moved1 && moved2;
-                }
-        }
-
-        private boolean skipNode() {
-                if (isTerminated()) {
-                        throw new IllegalStateException("DiffCursor tries to skip when terminated!");
-                }
-                boolean update1 = cursor1.skipCurrentNode();
-                boolean update2 = cursor2.skipCurrentNode();
-                updateState();
-                return update1 && update2;
-        }
-
-        protected boolean moveToConsistentState() {
-                if (!isTerminated()) {
-                        boolean changed;
-                        boolean lastResult = true;
-                        do {
-                                changed = false;
-                                if (MapCursor.sameSubnode(cursor1, cursor2)) {
-                                        lastResult = skipNode();
-                                        changed = true;
-                                }
-                                if (sameValues()) {
-                                        lastResult = moveOne();
-                                        changed = true;
-                                }
-                                updateState();
-                        } while (changed && !isTerminated());
-                        return lastResult;
-                } else {
-                        return false;
-                }
-        }
-
-        public boolean move() {
-                if (!isTerminated()) {
-                        if (isInHashClash()) {
-                                this.resolveHashClashWithSecondEntry();
-                                return true;
-                        } else {
-                                if (moveOne()) {
-                                        return moveToConsistentState();
-                                } else {
-                                        return false;
-                                }
-                        }
-
-                } else
-                        return false;
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/Node.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/Node.java
deleted file mode 100644
index 958d645f..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/Node.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.map.internal;
-
-import java.util.Map;
-
-import tools.refinery.store.map.ContinousHashProvider;
-
-public abstract class Node<K,V>{
-        public static final int BRANCHING_FACTOR_BITS = 5;
-        public static final int FACTOR = 1<<BRANCHING_FACTOR_BITS;
-        protected static final int NUMBER_OF_FACTORS = Integer.SIZE / BRANCHING_FACTOR_BITS;
-        protected static final int FACTOR_MASK = FACTOR-1;
-        public static final int EFFECTIVE_BITS = BRANCHING_FACTOR_BITS * NUMBER_OF_FACTORS;
-
-        /**
-         * Calculates the index for the continuous hash.
-         * @param depth The depth of the node in the tree.
-         * @return The index of the continuous hash.
-         */
-        protected static int hashDepth(int depth) {
-                return depth/NUMBER_OF_FACTORS;
-        }
-
-        /**
-         * Calculates the which segment of a single hash should be used.
-         * @param depth The depth of the node in the tree.
-         * @return The segment of a hash code.
-         */
-        protected static int shiftDepth(int depth) {
-                return depth%NUMBER_OF_FACTORS;
-        }
-        /**
-         * Selects a segments from a complete hash for a given depth.
-         * @param hash A complete hash.
-         * @param shiftDepth The index of the segment.
-         * @return The segment as an integer.
-         */
-        protected static int hashFragment(int hash, int shiftDepth) {
-                if(shiftDepth<0 || Node.NUMBER_OF_FACTORS<shiftDepth) throw new IllegalArgumentException("Invalid shift depth! valid intervall=[0;5], input="+shiftDepth);
-                return (hash >>> shiftDepth*BRANCHING_FACTOR_BITS) & FACTOR_MASK;
-        }
-
-        /**
-         * Returns the hash code for a given depth. It may calculate new hash code, or reuse a hash code calculated for depth-1.
-         * @param key The key.
-         * @param hash Hash code for depth-1
-         * @param depth The depth.
-         * @return The new hash code.
-         */
-        protected int newHash(final ContinousHashProvider<? super K> hashProvider, K key, int hash, int depth) {
-                final int hashDepth = hashDepth(depth);
-                if(hashDepth>=ContinousHashProvider.MAX_PRACTICAL_DEPTH) {
-                        throw new IllegalArgumentException("Key "+key+" have the clashing hashcode over the practical depth limitation ("+ContinousHashProvider.MAX_PRACTICAL_DEPTH+")!");
-                }
-                return depth%NUMBER_OF_FACTORS == 0?
-                                hashProvider.getHash(key, hashDepth) :
-                                hash;
-        }
-
-
-        public abstract V getValue(K key, ContinousHashProvider<? super K> hashProvider, V defaultValue,  int hash, int depth);
-        public abstract Node<K,V> putValue(K key, V value, OldValueBox<V> old, ContinousHashProvider<? super K> hashProvider, V defaultValue, int hash, int depth);
-        public abstract long getSize();
-
-        abstract MutableNode<K, V> toMutable();
-        public abstract ImmutableNode<K, V> toImmutable(
-                        Map<Node<K, V>,ImmutableNode<K, V>> cache);
-        protected abstract MutableNode<K, V> isMutable();
-        /**
-         * Moves a {@link MapCursor} to its next position.
-         * @param cursor the cursor
-         * @return Whether there was a next nodeId to move on.
-         */
-        abstract boolean moveToNext(MapCursor<K,V> cursor);
-
-        ///////// FOR printing
-        public abstract void prettyPrint(StringBuilder builder, int depth, int code);
-        @Override
-        public String toString() {
-                StringBuilder stringBuilder = new StringBuilder();
-                prettyPrint(stringBuilder, 0, -1);
-                return stringBuilder.toString();
-        }
-        public void checkIntegrity(ContinousHashProvider<? super K> hashProvider, V defaultValue, int depth) {}
-
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapStoreFactoryBuilderImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapStoreFactoryBuilderImpl.java
new file mode 100644
index 00000000..9f419ce1
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapStoreFactoryBuilderImpl.java
@@ -0,0 +1,150 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal;
+
+import tools.refinery.store.map.ContinuousHashProvider;
+import tools.refinery.store.map.VersionedMapStoreFactory;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
+import tools.refinery.store.map.internal.delta.DeltaBasedVersionedMapStoreFactory;
+import tools.refinery.store.map.internal.state.StateBasedVersionedMapStoreFactory;
+
+public class VersionedMapStoreFactoryBuilderImpl<K, V> implements VersionedMapStoreFactoryBuilder<K, V> {
+
+        private boolean defaultSet = false;
+        private V defaultValue;
+        private StoreStrategy strategy = null;
+        private Boolean transformToImmutable = null;
+        private SharingStrategy sharingStrategy = null;
+        private Boolean enableVersionFreeing = null;
+        private ContinuousHashProvider<K> continuousHashProvider = null;
+        private DeltaTransactionStrategy deltaTransactionStrategy = null;
+
+        private StoreStrategy checkStrategy() {
+                StoreStrategy currentStrategy = strategy;
+                currentStrategy = mergeStrategies(currentStrategy, transformToImmutable, StoreStrategy.STATE);
+                currentStrategy = mergeStrategies(currentStrategy, sharingStrategy, StoreStrategy.STATE);
+                currentStrategy = mergeStrategies(currentStrategy, continuousHashProvider, StoreStrategy.STATE);
+                currentStrategy = mergeStrategies(currentStrategy, deltaTransactionStrategy, StoreStrategy.DELTA);
+                return currentStrategy;
+        }
+
+        private StoreStrategy mergeStrategies(StoreStrategy old, StoreStrategy newStrategy) {
+                if (old != null && newStrategy != null && old != newStrategy) {
+                        throw new IllegalArgumentException("Mixed strategy parametrization in VersionedMap builder!");
+                }
+
+                if (old != null) {
+                        return old;
+                } else {
+                        return newStrategy;
+                }
+        }
+
+        private StoreStrategy mergeStrategies(StoreStrategy old, Object parameter, StoreStrategy newStrategy) {
+                if (parameter != null) {
+                        return mergeStrategies(old, newStrategy);
+                } else {
+                        return old;
+                }
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> defaultValue(V defaultValue) {
+                this.defaultSet = true;
+                this.defaultValue = defaultValue;
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> strategy(StoreStrategy strategy) {
+                this.strategy = strategy;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> versionFreeing(boolean enabled) {
+                this.enableVersionFreeing = enabled;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> stateBasedImmutableWhenCommitting(boolean transformToImmutable) {
+                this.transformToImmutable = transformToImmutable;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> stateBasedSharingStrategy(SharingStrategy sharingStrategy) {
+                this.sharingStrategy = sharingStrategy;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> stateBasedHashProvider(ContinuousHashProvider<K> hashProvider) {
+                this.continuousHashProvider = hashProvider;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> deltaTransactionStrategy(DeltaTransactionStrategy deltaTransactionStrategy) {
+                this.deltaTransactionStrategy = deltaTransactionStrategy;
+                checkStrategy();
+                return this;
+        }
+
+        private <T> T getOrDefault(T value, T defaultValue) {
+                if(value != null) {
+                        return value;
+                } else {
+                        return defaultValue;
+                }
+        }
+
+        @Override
+        public VersionedMapStoreFactory<K, V> build() {
+                if (!defaultSet) {
+                        throw new IllegalArgumentException("Default value is missing!");
+                }
+                var strategyToUse = checkStrategy();
+                if (strategyToUse == null) {
+                        return new DeltaBasedVersionedMapStoreFactory<>(defaultValue,
+                                        getOrDefault(deltaTransactionStrategy, DeltaTransactionStrategy.LIST));
+                }
+                return switch (strategyToUse) {
+                        case STATE -> {
+                                if(continuousHashProvider == null) {
+                                        throw new IllegalArgumentException("Continuous hash provider is missing!");
+                                }
+                                yield new StateBasedVersionedMapStoreFactory<>(defaultValue,
+                                                getOrDefault(transformToImmutable,true),
+                                                getOrDefault(sharingStrategy, SharingStrategy.SHARED_NODE_CACHE_IN_GROUP),
+                                                getOrDefault(enableVersionFreeing, true),
+                                                continuousHashProvider);
+                        }
+                        case DELTA -> new DeltaBasedVersionedMapStoreFactory<>(defaultValue,
+                                        getOrDefault(deltaTransactionStrategy, DeltaTransactionStrategy.LIST));
+                };
+        }
+
+        @Override
+        public String toString() {
+                return "VersionedMapStoreFactoryBuilderImpl{" +
+                                "defaultSet=" + defaultSet +
+                                ", defaultValue=" + defaultValue +
+                                ", strategy=" + strategy +
+                                ", transformToImmutable=" + transformToImmutable +
+                                ", sharingStrategy=" + sharingStrategy +
+                                ", enableVersionFreeing=" + enableVersionFreeing +
+                                ", continuousHashProvider=" + continuousHashProvider +
+                                ", deltaTransactionStrategy=" + deltaTransactionStrategy +
+                                '}';
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/DeltaBasedVersionedMapStoreFactory.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/DeltaBasedVersionedMapStoreFactory.java
new file mode 100644
index 00000000..cedcdc0b
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/DeltaBasedVersionedMapStoreFactory.java
@@ -0,0 +1,38 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.delta;
+
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreFactory;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DeltaBasedVersionedMapStoreFactory<K, V> implements VersionedMapStoreFactory<K, V> {
+        private final V defaultValue;
+        private final boolean summarizeChanges;
+
+        public DeltaBasedVersionedMapStoreFactory(V defaultValue,
+                                                                                          VersionedMapStoreFactoryBuilder.DeltaTransactionStrategy deltaTransactionStrategy) {
+                this.defaultValue = defaultValue;
+                this.summarizeChanges = deltaTransactionStrategy == VersionedMapStoreFactoryBuilder.DeltaTransactionStrategy.SET;
+        }
+
+        @Override
+        public VersionedMapStore<K, V> createOne() {
+                return new VersionedMapStoreDeltaImpl<>(summarizeChanges, defaultValue);
+        }
+
+        @Override
+        public List<VersionedMapStore<K, V>> createGroup(int amount) {
+                List<VersionedMapStore<K, V>> result = new ArrayList<>(amount);
+                for(int i=0; i<amount; i++) {
+                        result.add(new VersionedMapStoreDeltaImpl<>(summarizeChanges,defaultValue));
+                }
+                return result;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/DeltaDiffCursor.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/DeltaDiffCursor.java
new file mode 100644
index 00000000..ce10b246
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/DeltaDiffCursor.java
@@ -0,0 +1,147 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.delta;
+
+import tools.refinery.store.map.AnyVersionedMap;
+import tools.refinery.store.map.DiffCursor;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+public class DeltaDiffCursor<K, V> implements DiffCursor<K, V> {
+        final List<MapDelta<K, V>[]> backwardTransactions;
+        final List<MapDelta<K, V>[]> forwardTransactions;
+
+        boolean started;
+        /**
+         * Denotes the direction of traversal. False means backwards, true means
+         * forward.
+         */
+        boolean direction;
+        int listIndex;
+        int arrayIndex;
+
+        public DeltaDiffCursor(List<MapDelta<K, V>[]> backwardTransactions, List<MapDelta<K, V>[]> forwardTransactions) {
+                this.backwardTransactions = backwardTransactions;
+                this.forwardTransactions = forwardTransactions;
+
+                if (!backwardTransactions.isEmpty()) {
+                        direction = false;
+                        listIndex = 0;
+                        arrayIndex = backwardTransactions.get(listIndex).length - 1;
+                } else if (!forwardTransactions.isEmpty()) {
+                        direction = true;
+                        listIndex = forwardTransactions.size() - 1;
+                        arrayIndex = 0;
+                } else {
+                        direction = true;
+                        listIndex = -1;
+                }
+                started = false;
+        }
+
+        protected MapDelta<K, V> getCurrentDelta() {
+                final List<MapDelta<K, V>[]> list;
+                if (!direction) {
+                        list = this.backwardTransactions;
+                } else {
+                        list = this.forwardTransactions;
+                }
+                return list.get(listIndex)[arrayIndex];
+        }
+
+        @Override
+        public K getKey() {
+                return getCurrentDelta().getKey();
+        }
+
+        @Override
+        public V getValue() {
+                return getToValue();
+        }
+
+        @Override
+        public boolean isTerminated() {
+                return this.direction && listIndex == -1;
+        }
+
+
+        @Override
+        public boolean move() {
+                if(!started) {
+                        started = true;
+                        return !isTerminated();
+                } else if (isTerminated()) {
+                        return false;
+                } else {
+                        if (this.direction) {
+                                if (arrayIndex+1 < forwardTransactions.get(listIndex).length) {
+                                        arrayIndex++;
+                                        return true;
+                                } else {
+                                        if (listIndex-1 >= 0) {
+                                                listIndex--;
+                                                arrayIndex = 0;
+                                                return true;
+                                        } else {
+                                                listIndex = -1;
+                                                return false;
+                                        }
+                                }
+                        } else {
+                                if (arrayIndex > 0) {
+                                        arrayIndex--;
+                                        return true;
+                                } else {
+                                        if (listIndex+1 < backwardTransactions.size()) {
+                                                listIndex++;
+                                                this.arrayIndex = backwardTransactions.get(listIndex).length - 1;
+                                                return true;
+                                        } else {
+                                                this.direction = true;
+                                                if (!this.forwardTransactions.isEmpty()) {
+                                                        listIndex = forwardTransactions.size() - 1;
+                                                        arrayIndex = 0;
+                                                        return true;
+                                                } else {
+                                                        listIndex = -1;
+                                                        return false;
+                                                }
+                                        }
+                                }
+                        }
+                }
+        }
+
+        @Override
+        public boolean isDirty() {
+                return false;
+        }
+
+        @Override
+        public Set<AnyVersionedMap> getDependingMaps() {
+                return Collections.emptySet();
+        }
+
+        @Override
+        public V getFromValue() {
+                if(this.direction) {
+                        return getCurrentDelta().getOldValue();
+                } else {
+                        return getCurrentDelta().getNewValue();
+                }
+        }
+
+        @Override
+        public V getToValue() {
+                if(this.direction) {
+                        return getCurrentDelta().getNewValue();
+                } else {
+                        return getCurrentDelta().getOldValue();
+                }
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/MapDelta.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/MapDelta.java
new file mode 100644
index 00000000..0c0cc906
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/MapDelta.java
@@ -0,0 +1,20 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.delta;
+
+public record MapDelta<K, V>(K key, V oldValue, V newValue) {
+        public K getKey() {
+                return key;
+        }
+
+        public V getOldValue() {
+                return oldValue;
+        }
+
+        public V getNewValue() {
+                return newValue;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/MapTransaction.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/MapTransaction.java
new file mode 100644
index 00000000..6f3fa6d7
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/MapTransaction.java
@@ -0,0 +1,41 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.delta;
+
+import tools.refinery.store.map.Version;
+
+import java.util.Arrays;
+import java.util.Objects;
+
+public record MapTransaction<K, V>(MapDelta<K, V>[] deltas, MapTransaction<K, V> parent, int depth) implements Version {
+
+        @Override
+        public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result + Arrays.hashCode(deltas);
+                result = prime * result + Objects.hash(parent, depth);
+                return result;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (this == obj)
+                        return true;
+                if (obj == null)
+                        return false;
+                if (getClass() != obj.getClass())
+                        return false;
+                @SuppressWarnings("unchecked")
+                MapTransaction<K, V> other = (MapTransaction<K, V>) obj;
+                return depth == other.depth && Objects.equals(parent, other.parent) && Arrays.equals(deltas, other.deltas);
+        }
+
+        @Override
+        public String toString() {
+                return "MapTransaction " + depth + " " + Arrays.toString(deltas);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/UncommittedDeltaArrayStore.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/UncommittedDeltaArrayStore.java
new file mode 100644
index 00000000..1f6a9000
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/UncommittedDeltaArrayStore.java
@@ -0,0 +1,36 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.delta;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class UncommittedDeltaArrayStore<K, V> implements UncommittedDeltaStore<K, V> {
+        final List<MapDelta<K, V>> uncommittedOldValues = new ArrayList<>();
+
+        @Override
+        public void processChange(K key, V oldValue, V newValue) {
+                uncommittedOldValues.add(new MapDelta<>(key, oldValue, newValue));
+        }
+
+        @Override
+        public MapDelta<K, V>[] extractDeltas() {
+                if (uncommittedOldValues.isEmpty()) {
+                        return null;
+                } else {
+                        @SuppressWarnings("unchecked")
+                        MapDelta<K, V>[] result = uncommittedOldValues.toArray(new MapDelta[0]);
+                        return result;
+                }
+        }
+
+        @Override
+        public MapDelta<K, V>[] extractAndDeleteDeltas() {
+                MapDelta<K, V>[] res = extractDeltas();
+                this.uncommittedOldValues.clear();
+                return res;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/UncommittedDeltaMapStore.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/UncommittedDeltaMapStore.java
new file mode 100644
index 00000000..644884a6
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/UncommittedDeltaMapStore.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.delta;
+
+import java.util.*;
+import java.util.Map.Entry;
+
+import tools.refinery.store.map.VersionedMap;
+
+public class UncommittedDeltaMapStore<K, V> implements UncommittedDeltaStore<K, V> {
+        final VersionedMap<K, V> source;
+        final Map<K, V> uncommittedOldValues = new HashMap<>();
+
+        public UncommittedDeltaMapStore(VersionedMap<K, V> source) {
+                this.source = source;
+        }
+
+        @Override
+        public void processChange(K key, V oldValue, V newValue) {
+                if(!uncommittedOldValues.containsKey(key)) {
+                        this.uncommittedOldValues.put(key,oldValue);
+                }
+        }
+
+        @Override
+        public MapDelta<K, V>[] extractDeltas() {
+                if (uncommittedOldValues.isEmpty()) {
+                        return null;
+                } else {
+                        @SuppressWarnings("unchecked")
+                        MapDelta<K,V>[] deltas = new MapDelta[uncommittedOldValues.size()];
+                        int i = 0;
+                        for (Entry<K, V> entry : uncommittedOldValues.entrySet()) {
+                                final K key = entry.getKey();
+                                final V oldValue = entry.getValue();
+                                final V newValue = source.get(key);
+                                deltas[i++] = new MapDelta<>(key, oldValue, newValue);
+                        }
+
+                        return deltas;
+                }
+        }
+
+        @Override
+        public MapDelta<K, V>[] extractAndDeleteDeltas() {
+                MapDelta<K, V>[] res = extractDeltas();
+                this.uncommittedOldValues.clear();
+                return res;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/UncommittedDeltaStore.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/UncommittedDeltaStore.java
new file mode 100644
index 00000000..ecd33c5f
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/UncommittedDeltaStore.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.delta;
+
+public interface UncommittedDeltaStore<K, V> {
+        void processChange(K key, V oldValue, V newValue);
+
+        MapDelta<K, V>[] extractDeltas();
+
+        MapDelta<K, V>[] extractAndDeleteDeltas();
+
+        default void checkIntegrity() {
+                MapDelta<K, V>[] extractedDeltas = extractDeltas();
+                if(extractedDeltas != null) {
+                        for(var uncommittedOldValue : extractedDeltas) {
+                                if(uncommittedOldValue == null) {
+                                        throw new IllegalArgumentException("Null entry in deltas!");
+                                }
+                                if(uncommittedOldValue.getKey() == null) {
+                                        throw new IllegalStateException("Null key in deltas!");
+                                }
+                        }
+                }
+        }
+
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapDeltaImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapDeltaImpl.java
new file mode 100644
index 00000000..d530ae87
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapDeltaImpl.java
@@ -0,0 +1,237 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.delta;
+
+import tools.refinery.store.map.*;
+
+import java.util.*;
+
+public class VersionedMapDeltaImpl<K, V> implements VersionedMap<K, V> {
+        protected final VersionedMapStoreDeltaImpl<K, V> store;
+
+        final Map<K, V> current;
+
+        final UncommittedDeltaStore<K, V> uncommittedStore;
+        MapTransaction<K, V> previous;
+
+        protected final V defaultValue;
+
+        public VersionedMapDeltaImpl(VersionedMapStoreDeltaImpl<K, V> store, boolean summarizeChanges, V defaultValue) {
+                this.store = store;
+                this.defaultValue = defaultValue;
+
+                current = new HashMap<>();
+                if (summarizeChanges) {
+                        this.uncommittedStore = new UncommittedDeltaMapStore<>(this);
+                } else {
+                        this.uncommittedStore = new UncommittedDeltaArrayStore<>();
+                }
+        }
+
+        @Override
+        public V getDefaultValue() {
+                return defaultValue;
+        }
+
+        @Override
+        public Version commit() {
+                MapDelta<K, V>[] deltas = uncommittedStore.extractAndDeleteDeltas();
+                final MapTransaction<K,V> committedTransaction = this.store.appendTransaction(deltas, previous);
+                this.previous = committedTransaction;
+                return committedTransaction;
+        }
+
+        @Override
+        public void restore(Version state) {
+                // 1. restore uncommitted states
+                MapDelta<K, V>[] uncommitted = this.uncommittedStore.extractAndDeleteDeltas();
+                if (uncommitted != null) {
+                        backward(uncommitted);
+                }
+
+                // 2. get common ancestor
+                final MapTransaction<K,V> parent;
+                List<MapDelta<K, V>[]> forward = new ArrayList<>();
+                if (this.previous == null) {
+                        parent = this.store.getPath(state, forward);
+                        this.forward(forward);
+                } else {
+                        List<MapDelta<K, V>[]> backward = new ArrayList<>();
+                        parent = this.store.getPath(this.previous, state, backward, forward);
+                        this.backward(backward);
+                        this.forward(forward);
+                }
+                this.previous = parent;
+        }
+
+        protected void forward(List<MapDelta<K, V>[]> changes) {
+                for (int i = changes.size() - 1; i >= 0; i--) {
+                        forward(changes.get(i));
+                }
+        }
+
+        protected void backward(List<MapDelta<K, V>[]> changes) {
+                //Currently, this loop statement is faster.
+                //noinspection ForLoopReplaceableByForEach
+                for (int i = 0; i < changes.size(); i++) {
+                        backward(changes.get(i));
+                }
+        }
+
+        protected void forward(MapDelta<K, V>[] changes) {
+                //Currently, this loop statement is faster.
+                //noinspection ForLoopReplaceableByForEach
+                for (int i = 0; i < changes.length; i++) {
+                        final MapDelta<K, V> change = changes[i];
+                        K key = change.getKey();
+                        V newValue = change.getNewValue();
+
+                        if(newValue == defaultValue) {
+                                current.remove(key);
+                        } else {
+                                current.put(key,newValue);
+                        }
+                }
+        }
+
+        protected void backward(MapDelta<K, V>[] changes) {
+                for (int i = changes.length - 1; i >= 0; i--) {
+                        final MapDelta<K, V> change = changes[i];
+                        K key = change.getKey();
+                        V oldValue = change.oldValue();
+
+                        if(oldValue == defaultValue) {
+                                current.remove(key);
+                        } else {
+                                current.put(key,oldValue);
+                        }
+                }
+        }
+
+        @Override
+        public V get(K key) {
+                return current.getOrDefault(key, defaultValue);
+        }
+
+        @Override
+        public Cursor<K, V> getAll() {
+                return new IteratorAsCursor<>(this, current);
+        }
+
+        @Override
+        public V put(K key, V value) {
+                final V oldValue;
+                if (Objects.equals(value, defaultValue)) {
+                        final V res = current.remove(key);
+                        if (res == null) {
+                                // no changes: default > default
+                                oldValue = defaultValue;
+                        } else {
+                                oldValue = res;
+                        }
+                } else {
+                        final var mapValue = current.put(key, value);
+                        if (mapValue == null) {
+                                oldValue = defaultValue;
+                        } else {
+                                oldValue = mapValue;
+                        }
+                }
+                if(!Objects.equals(oldValue,value)) {
+                        uncommittedStore.processChange(key, oldValue, value);
+                }
+                return oldValue;
+        }
+
+        @Override
+        public void putAll(Cursor<K, V> cursor) {
+                if (cursor.getDependingMaps().contains(this)) {
+                        List<K> keys = new ArrayList<>();
+                        List<V> values = new ArrayList<>();
+                        while (cursor.move()) {
+                                keys.add(cursor.getKey());
+                                values.add(cursor.getValue());
+                        }
+                        for (int i = 0; i < keys.size(); i++) {
+                                this.put(keys.get(i), values.get(i));
+                        }
+                } else {
+                        while (cursor.move()) {
+                                this.put(cursor.getKey(), cursor.getValue());
+                        }
+                }
+        }
+
+        @Override
+        public long getSize() {
+                return current.size();
+        }
+
+        @Override
+        public DiffCursor<K, V> getDiffCursor(Version state) {
+                MapDelta<K, V>[] backward = this.uncommittedStore.extractDeltas();
+                List<MapDelta<K, V>[]> backwardTransactions = new ArrayList<>();
+                List<MapDelta<K, V>[]> forwardTransactions = new ArrayList<>();
+
+                if (backward != null) {
+                        backwardTransactions.add(backward);
+                }
+
+                if (this.previous != null) {
+                        store.getPath(this.previous, state, backwardTransactions, forwardTransactions);
+                } else {
+                        store.getPath(state, forwardTransactions);
+                }
+
+                return new DeltaDiffCursor<>(backwardTransactions, forwardTransactions);
+        }
+
+        @Override
+        public int contentHashCode(ContentHashCode mode) {
+                return this.current.hashCode();
+        }
+
+        @Override
+        public boolean contentEquals(AnyVersionedMap other) {
+                if (other instanceof VersionedMapDeltaImpl<?, ?> versioned) {
+                        if (versioned == this) {
+                                return true;
+                        } else {
+                                return Objects.equals(this.defaultValue, versioned.defaultValue) && Objects.equals(this.current, versioned.current);
+                        }
+                } else {
+                        throw new UnsupportedOperationException("Comparing different map implementations is ineffective.");
+                }
+        }
+
+        @Override
+        public void checkIntegrity() {
+                this.uncommittedStore.checkIntegrity();
+
+                for (var entry : this.current.entrySet()) {
+                        var value = entry.getValue();
+                        if (value == this.defaultValue) {
+                                throw new IllegalStateException("Default value stored in map!");
+                        } else if (value == null) {
+                                throw new IllegalStateException("null value stored in map!");
+                        }
+                }
+                MapTransaction<K,V> transaction = this.previous;
+                while(transaction != null) {
+                        MapTransaction<K,V> parent = transaction.parent();
+                        if(parent != null) {
+                                if(parent.depth() != transaction.depth()-1) {
+                                        throw new IllegalStateException("Parent depths are inconsistent!");
+                                }
+                        } else {
+                                if(transaction.depth() != 0) {
+                                        throw new IllegalArgumentException("Root depth is not 0!");
+                                }
+                        }
+                        transaction = transaction.parent();
+                }
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapStoreDeltaImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapStoreDeltaImpl.java
new file mode 100644
index 00000000..ed169409
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapStoreDeltaImpl.java
@@ -0,0 +1,94 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.delta;
+
+import tools.refinery.store.map.DiffCursor;
+import tools.refinery.store.map.Version;
+import tools.refinery.store.map.VersionedMap;
+import tools.refinery.store.map.VersionedMapStore;
+
+import java.util.*;
+
+public class VersionedMapStoreDeltaImpl<K, V> implements VersionedMapStore<K, V> {
+        // Configuration
+        protected final boolean summarizeChanges;
+
+        // Static data
+        protected final V defaultValue;
+
+        public VersionedMapStoreDeltaImpl(boolean summarizeChanges, V defaultValue) {
+                this.summarizeChanges = summarizeChanges;
+                this.defaultValue = defaultValue;
+        }
+
+        @Override
+        public VersionedMap<K, V> createMap() {
+                return new VersionedMapDeltaImpl<>(this, this.summarizeChanges, this.defaultValue);
+        }
+
+        @Override
+        public VersionedMap<K, V> createMap(Version state) {
+                VersionedMapDeltaImpl<K, V> result = new VersionedMapDeltaImpl<>(this, this.summarizeChanges, this.defaultValue);
+                result.restore(state);
+                return result;
+        }
+
+        public MapTransaction<K, V> appendTransaction(MapDelta<K, V>[] deltas, MapTransaction<K, V> previous) {
+                if (deltas == null) {
+                        return previous;
+                } else {
+                        final int depth;
+                        if(previous != null) {
+                                depth = previous.depth()+1;
+                        } else {
+                                depth = 0;
+                        }
+                        return new MapTransaction<>(deltas, previous, depth);
+                }
+        }
+
+        @SuppressWarnings("unchecked")
+        private MapTransaction<K, V> getState(Version state) {
+                return (MapTransaction<K, V>) state;
+        }
+
+        public MapTransaction<K, V> getPath(Version to, List<MapDelta<K, V>[]> forwardTransactions) {
+                final MapTransaction<K, V> target = getState(to);
+                MapTransaction<K, V> toTransaction = target;
+                while (toTransaction != null) {
+                        forwardTransactions.add(toTransaction.deltas());
+                        toTransaction = toTransaction.parent();
+                }
+                return target;
+        }
+
+        public MapTransaction<K, V> getPath(Version from, Version to,
+                                                List<MapDelta<K, V>[]> backwardTransactions,
+                                                List<MapDelta<K, V>[]> forwardTransactions) {
+                MapTransaction<K, V> fromTransaction = getState(from);
+                final MapTransaction<K, V> target = getState(to);
+                MapTransaction<K, V> toTransaction = target;
+
+                while (fromTransaction != toTransaction) {
+                        if (fromTransaction == null || (toTransaction != null && fromTransaction.depth() < toTransaction.depth())) {
+                                forwardTransactions.add(toTransaction.deltas());
+                                toTransaction = toTransaction.parent();
+                        } else {
+                                backwardTransactions.add(fromTransaction.deltas());
+                                fromTransaction = fromTransaction.parent();
+                        }
+                }
+                return target;
+        }
+
+        @Override
+        public DiffCursor<K, V> getDiffCursor(Version fromState, Version toState) {
+                List<MapDelta<K, V>[]> backwardTransactions = new ArrayList<>();
+                List<MapDelta<K, V>[]> forwardTransactions = new ArrayList<>();
+                getPath(fromState, toState, backwardTransactions, forwardTransactions);
+                return new DeltaDiffCursor<>(backwardTransactions, forwardTransactions);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/ImmutableNode.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/ImmutableNode.java
index 03dffc15..5b1d8b77 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/ImmutableNode.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/ImmutableNode.java
@@ -1,16 +1,17 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.store.map.internal;
+package tools.refinery.store.map.internal.state;
 
 import java.util.Arrays;
 import java.util.Map;
 
-import tools.refinery.store.map.ContinousHashProvider;
+import tools.refinery.store.map.ContinuousHashProvider;
+import tools.refinery.store.map.Version;
 
-public class ImmutableNode<K, V> extends Node<K, V> {
+public class ImmutableNode<K, V> extends Node<K, V> implements Version {
         /**
          * Bitmap defining the stored key and values.
          */
@@ -20,7 +21,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
          */
         final int nodeMap;
         /**
-         * Stores Keys, Values, and subnodes. Structure: (K,V)*,NODE; NODES are stored
+         * Stores Keys, Values, and sub-nodes. Structure: (K,V)*,NODE; NODES are stored
          * backwards.
          */
         final Object[] content;
@@ -47,8 +48,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
          *              available.
          * @return an immutable version of the input node.
          */
-        static <K, V> ImmutableNode<K, V> constructImmutable(MutableNode<K, V> node,
-                        Map<Node<K, V>, ImmutableNode<K, V>> cache) {
+        static <K, V> ImmutableNode<K, V> constructImmutable(MutableNode<K, V> node, Map<Node<K, V>, ImmutableNode<K, V>> cache) {
                 // 1. try to return from cache
                 if (cache != null) {
                         ImmutableNode<K, V> cachedResult = cache.get(node);
@@ -71,25 +71,24 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                 int resultDataMap = 0;
                 int resultNodeMap = 0;
                 final Object[] resultContent = new Object[size];
-                int bitposition = 1;
+                int bitPosition = 1;
                 for (int i = 0; i < FACTOR; i++) {
                         Object key = node.content[i * 2];
                         if (key != null) {
-                                resultDataMap |= bitposition;
+                                resultDataMap |= bitPosition;
                                 resultContent[datas * 2] = key;
                                 resultContent[datas * 2 + 1] = node.content[i * 2 + 1];
                                 datas++;
                         } else {
-                                @SuppressWarnings("unchecked")
-                                var subnode = (Node<K, V>) node.content[i * 2 + 1];
+                                @SuppressWarnings("unchecked") var subnode = (Node<K, V>) node.content[i * 2 + 1];
                                 if (subnode != null) {
-                                        ImmutableNode<K, V> immutableSubnode = subnode.toImmutable(cache);
-                                        resultNodeMap |= bitposition;
-                                        resultContent[size - 1 - nodes] = immutableSubnode;
+                                        ImmutableNode<K, V> immutableSubNode = subnode.toImmutable(cache);
+                                        resultNodeMap |= bitPosition;
+                                        resultContent[size - 1 - nodes] = immutableSubNode;
                                         nodes++;
                                 }
                         }
-                        bitposition <<= 1;
+                        bitPosition <<= 1;
                 }
                 final int resultHash = node.hashCode();
                 var newImmutable = new ImmutableNode<K, V>(resultDataMap, resultNodeMap, resultContent, resultHash);
@@ -106,17 +105,15 @@ public class ImmutableNode<K, V> extends Node<K, V> {
         }
 
         @Override
-        public V getValue(K key, ContinousHashProvider<? super K> hashProvider, V defaultValue, int hash, int depth) {
+        public V getValue(K key, ContinuousHashProvider<? super K> hashProvider, V defaultValue, int hash, int depth) {
                 int selectedHashFragment = hashFragment(hash, shiftDepth(depth));
                 int bitposition = 1 << selectedHashFragment;
                 // If the key is stored as a data
                 if ((dataMap & bitposition) != 0) {
                         int keyIndex = 2 * index(dataMap, bitposition);
-                        @SuppressWarnings("unchecked")
-                        K keyCandidate = (K) content[keyIndex];
+                        @SuppressWarnings("unchecked") K keyCandidate = (K) content[keyIndex];
                         if (keyCandidate.equals(key)) {
-                                @SuppressWarnings("unchecked")
-                                V value = (V) content[keyIndex + 1];
+                                @SuppressWarnings("unchecked") V value = (V) content[keyIndex + 1];
                                 return value;
                         } else {
                                 return defaultValue;
@@ -125,9 +122,8 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                 // the key is stored as a node
                 else if ((nodeMap & bitposition) != 0) {
                         int keyIndex = content.length - 1 - index(nodeMap, bitposition);
-                        @SuppressWarnings("unchecked")
-                        var subNode = (ImmutableNode<K, V>) content[keyIndex];
-                        int newDepth = depth + 1;
+                        @SuppressWarnings("unchecked") var subNode = (ImmutableNode<K, V>) content[keyIndex];
+                        int newDepth = incrementDepth(depth);
                         int newHash = newHash(hashProvider, key, hash, newDepth);
                         return subNode.getValue(key, hashProvider, defaultValue, newHash, newDepth);
                 }
@@ -138,44 +134,41 @@ public class ImmutableNode<K, V> extends Node<K, V> {
         }
 
         @Override
-        public Node<K, V> putValue(K key, V value, OldValueBox<V> oldValue, ContinousHashProvider<? super K> hashProvider,
-                        V defaultValue, int hash, int depth) {
+        public Node<K, V> putValue(K key, V value, OldValueBox<V> oldValue, ContinuousHashProvider<? super K> hashProvider, V defaultValue, int hash, int depth) {
                 int selectedHashFragment = hashFragment(hash, shiftDepth(depth));
-                int bitposition = 1 << selectedHashFragment;
-                if ((dataMap & bitposition) != 0) {
-                        int keyIndex = 2 * index(dataMap, bitposition);
-                        @SuppressWarnings("unchecked")
-                        K keyCandidate = (K) content[keyIndex];
+                int bitPosition = 1 << selectedHashFragment;
+                if ((dataMap & bitPosition) != 0) {
+                        int keyIndex = 2 * index(dataMap, bitPosition);
+                        @SuppressWarnings("unchecked") K keyCandidate = (K) content[keyIndex];
                         if (keyCandidate.equals(key)) {
                                 if (value == defaultValue) {
                                         // delete
                                         MutableNode<K, V> mutable = this.toMutable();
                                         return mutable.removeEntry(selectedHashFragment, oldValue);
                                 } else if (value == content[keyIndex + 1]) {
-                                        // dont change
+                                        // don't change
                                         oldValue.setOldValue(value);
                                         return this;
                                 } else {
-                                        // update existing nodeId
+                                        // update existing value
                                         MutableNode<K, V> mutable = this.toMutable();
                                         return mutable.updateValue(value, oldValue, selectedHashFragment);
                                 }
                         } else {
                                 if (value == defaultValue) {
-                                        // dont change
+                                        // don't change
                                         oldValue.setOldValue(defaultValue);
                                         return this;
                                 } else {
-                                        // add new key + nodeId
+                                        // add new key + value
                                         MutableNode<K, V> mutable = this.toMutable();
                                         return mutable.putValue(key, value, oldValue, hashProvider, defaultValue, hash, depth);
                                 }
                         }
-                } else if ((nodeMap & bitposition) != 0) {
-                        int keyIndex = content.length - 1 - index(nodeMap, bitposition);
-                        @SuppressWarnings("unchecked")
-                        var subNode = (ImmutableNode<K, V>) content[keyIndex];
-                        int newDepth = depth + 1;
+                } else if ((nodeMap & bitPosition) != 0) {
+                        int keyIndex = content.length - 1 - index(nodeMap, bitPosition);
+                        @SuppressWarnings("unchecked") var subNode = (ImmutableNode<K, V>) content[keyIndex];
+                        int newDepth = incrementDepth(depth);
                         int newHash = newHash(hashProvider, key, hash, newDepth);
                         var newsubNode = subNode.putValue(key, value, oldValue, hashProvider, defaultValue, newHash, newDepth);
 
@@ -184,10 +177,11 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                                 return this;
                         } else {
                                 MutableNode<K, V> mutable = toMutable();
-                                return mutable.updateWithSubNode(selectedHashFragment, newsubNode, value.equals(defaultValue));
+                                return mutable.updateWithSubNode(selectedHashFragment, newsubNode,
+                                                (value == null && defaultValue == null) || (value != null && value.equals(defaultValue)));
                         }
                 } else {
-                        // add new key + nodeId
+                        // add new key + value
                         MutableNode<K, V> mutable = this.toMutable();
                         return mutable.putValue(key, value, oldValue, hashProvider, defaultValue, hash, depth);
                 }
@@ -197,8 +191,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
         public long getSize() {
                 int result = Integer.bitCount(this.dataMap);
                 for (int subnodeIndex = 0; subnodeIndex < Integer.bitCount(this.nodeMap); subnodeIndex++) {
-                        @SuppressWarnings("unchecked")
-                        var subnode = (ImmutableNode<K, V>) this.content[this.content.length - 1 - subnodeIndex];
+                        @SuppressWarnings("unchecked") var subnode = (ImmutableNode<K, V>) this.content[this.content.length - 1 - subnodeIndex];
                         result += subnode.getSize();
                 }
                 return result;
@@ -238,6 +231,9 @@ public class ImmutableNode<K, V> extends Node<K, V> {
 
                 // 2. look inside the subnodes
                 int nodes = Integer.bitCount(this.nodeMap);
+                if(cursor.nodeIndexStack.peek()==null) {
+                        throw new IllegalStateException("Cursor moved to the next state when the state is empty.");
+                }
                 int newNodeIndex = cursor.nodeIndexStack.peek() + 1;
                 if (newNodeIndex < nodes) {
                         // 2.1 found next subnode, move down to the subnode
@@ -264,10 +260,51 @@ public class ImmutableNode<K, V> extends Node<K, V> {
         }
 
         @Override
-        public void prettyPrint(StringBuilder builder, int depth, int code) {
-                for (int i = 0; i < depth; i++) {
-                        builder.append("\t");
+        @SuppressWarnings("unchecked")
+        boolean moveToNextInorder(InOrderMapCursor<K, V> cursor) {
+                if(cursor.nodeIndexStack.peek()==null) {
+                        throw new IllegalStateException("Cursor moved to the next state when the state is empty.");
                 }
+
+                int position = cursor.nodeIndexStack.peek();
+                for (int index = position + 1; index < FACTOR; index++) {
+                        final int mask = 1<<index;
+                        if((this.dataMap & mask) != 0) {
+                                // data found
+                                cursor.nodeIndexStack.pop();
+                                cursor.nodeIndexStack.push(index);
+
+                                cursor.key = (K) this.content[2 * index(dataMap, mask)];
+                                cursor.value = (V) this.content[2 * index(dataMap, mask) +1];
+                                return true;
+                        } else if((this.nodeMap & mask) != 0) {
+                                // node found
+                                Node<K,V> subnode = (Node<K, V>) this.content[this.content.length - 1 - index(nodeMap, mask)];
+                                cursor.nodeIndexStack.pop();
+                                cursor.nodeIndexStack.push(index);
+                                cursor.nodeIndexStack.push(InOrderMapCursor.INDEX_START);
+                                cursor.nodeStack.push(subnode);
+
+                                return subnode.moveToNextInorder(cursor);
+                        }
+                }
+
+                // nothing found
+                cursor.nodeStack.pop();
+                cursor.nodeIndexStack.pop();
+                if (!cursor.nodeStack.isEmpty()) {
+                        Node<K, V> supernode = cursor.nodeStack.peek();
+                        return supernode.moveToNextInorder(cursor);
+                } else {
+                        cursor.key = null;
+                        cursor.value = null;
+                        return false;
+                }
+        }
+
+        @Override
+        public void prettyPrint(StringBuilder builder, int depth, int code) {
+                builder.append("\t".repeat(Math.max(0, depth)));
                 if (code >= 0) {
                         builder.append(code);
                         builder.append(":");
@@ -294,17 +331,16 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                 int nodeMask = 1;
                 for (int i = 0; i < FACTOR; i++) {
                         if ((nodeMask & nodeMap) != 0) {
-                                @SuppressWarnings("unchecked")
-                                Node<K, V> subNode = (Node<K, V>) content[content.length - 1 - index(nodeMap, nodeMask)];
+                                @SuppressWarnings("unchecked") Node<K, V> subNode = (Node<K, V>) content[content.length - 1 - index(nodeMap, nodeMask)];
                                 builder.append("\n");
-                                subNode.prettyPrint(builder, depth + 1, i);
+                                subNode.prettyPrint(builder, incrementDepth(depth), i);
                         }
                         nodeMask <<= 1;
                 }
         }
 
         @Override
-        public void checkIntegrity(ContinousHashProvider<? super K> hashProvider, V defaultValue, int depth) {
+        public void checkIntegrity(ContinuousHashProvider<? super K> hashProvider, V defaultValue, int depth) {
                 if (depth > 0) {
                         boolean orphaned = Integer.bitCount(dataMap) == 1 && nodeMap == 0;
                         if (orphaned) {
@@ -315,12 +351,11 @@ public class ImmutableNode<K, V> extends Node<K, V> {
 
                 // check subnodes
                 for (int i = 0; i < Integer.bitCount(nodeMap); i++) {
-                        @SuppressWarnings("unchecked")
-                        var subnode = (Node<K, V>) this.content[this.content.length - 1 - i];
+                        @SuppressWarnings("unchecked") var subnode = (Node<K, V>) this.content[this.content.length - 1 - i];
                         if (!(subnode instanceof ImmutableNode<?, ?>)) {
                                 throw new IllegalStateException("Immutable node contains mutable subnodes!");
                         } else {
-                                subnode.checkIntegrity(hashProvider, defaultValue, depth + 1);
+                                subnode.checkIntegrity(hashProvider, defaultValue, incrementDepth(depth));
                         }
                 }
         }
@@ -332,13 +367,10 @@ public class ImmutableNode<K, V> extends Node<K, V> {
 
         @Override
         public boolean equals(Object obj) {
-                if (this == obj)
-                        return true;
-                if (obj == null)
-                        return false;
+                if (this == obj) return true;
+                if (obj == null) return false;
                 if (obj instanceof ImmutableNode<?, ?> other) {
-                        return precalculatedHash == other.precalculatedHash && dataMap == other.dataMap && nodeMap == other.nodeMap
-                                        && Arrays.deepEquals(content, other.content);
+                        return precalculatedHash == other.precalculatedHash && dataMap == other.dataMap && nodeMap == other.nodeMap && Arrays.deepEquals(content, other.content);
                 } else if (obj instanceof MutableNode<?, ?> mutableObj) {
                         return ImmutableNode.compareImmutableMutable(this, mutableObj);
                 } else {
@@ -356,19 +388,17 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                         if (key != null) {
                                 // Check whether a new Key-Value pair can fit into the immutable container
                                 if (datas * 2 + nodes + 2 <= immutableLength) {
-                                        if (!immutable.content[datas * 2].equals(key)
-                                                        || !immutable.content[datas * 2 + 1].equals(mutable.content[i * 2 + 1])) {
+                                        if (!immutable.content[datas * 2].equals(key) || !immutable.content[datas * 2 + 1].equals(mutable.content[i * 2 + 1])) {
                                                 return false;
                                         }
-                                } else
-                                        return false;
+                                } else return false;
                                 datas++;
                         } else {
                                 var mutableSubnode = (Node<?, ?>) mutable.content[i * 2 + 1];
                                 if (mutableSubnode != null) {
                                         if (datas * 2 + nodes + 1 <= immutableLength) {
-                                                Object immutableSubnode = immutable.content[immutableLength - 1 - nodes];
-                                                if (!mutableSubnode.equals(immutableSubnode)) {
+                                                Object immutableSubNode = immutable.content[immutableLength - 1 - nodes];
+                                                if (!mutableSubnode.equals(immutableSubNode)) {
                                                         return false;
                                                 }
                                                 nodes++;
@@ -378,6 +408,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                                 }
                         }
                 }
-                return true;
+
+                return datas * 2 + nodes == immutable.content.length;
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/InOrderMapCursor.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/InOrderMapCursor.java
new file mode 100644
index 00000000..7cc91004
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/InOrderMapCursor.java
@@ -0,0 +1,146 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.state;
+
+import tools.refinery.store.map.AnyVersionedMap;
+import tools.refinery.store.map.ContentHashCode;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.VersionedMap;
+
+import java.util.*;
+
+public class InOrderMapCursor<K, V> implements Cursor<K, V> {
+        // Constants
+        static final int INDEX_START = -1;
+
+        // Tree stack
+        ArrayDeque<Node<K, V>> nodeStack;
+        ArrayDeque<Integer> nodeIndexStack;
+
+
+        // Values
+        K key;
+        V value;
+
+        // Hash code for checking concurrent modifications
+        final VersionedMap<K, V> map;
+        final int creationHash;
+
+        public InOrderMapCursor(VersionedMapStateImpl<K, V> map) {
+                // Initializing tree stack
+                super();
+                this.nodeStack = new ArrayDeque<>();
+                this.nodeIndexStack = new ArrayDeque<>();
+                if (map.root != null) {
+                        this.nodeStack.add(map.root);
+                        this.nodeIndexStack.push(INDEX_START);
+                }
+
+                // Initializing cache
+                this.key = null;
+                this.value = null;
+
+                // Initializing state
+                this.map = map;
+                this.creationHash = map.contentHashCode(ContentHashCode.APPROXIMATE_FAST);
+        }
+
+        public K getKey() {
+                return key;
+        }
+
+        public V getValue() {
+                return value;
+        }
+
+        public boolean isTerminated() {
+                return this.nodeStack.isEmpty();
+        }
+
+        public boolean move() {
+                if (isDirty()) {
+                        throw new ConcurrentModificationException();
+                }
+                if (!isTerminated()) {
+                        var node = this.nodeStack.peek();
+                        if (node == null) {
+                                throw new IllegalStateException("Cursor is not terminated but the current node is missing");
+                        }
+                        boolean result = node.moveToNextInorder(this);
+                        if (this.nodeIndexStack.size() != this.nodeStack.size()) {
+                                throw new IllegalArgumentException("Node stack is corrupted by illegal moves!");
+                        }
+                        return result;
+                }
+                return false;
+        }
+
+        public boolean skipCurrentNode() {
+                nodeStack.pop();
+                nodeIndexStack.pop();
+                return move();
+        }
+
+        @Override
+        public boolean isDirty() {
+                return this.map.contentHashCode(ContentHashCode.APPROXIMATE_FAST) != this.creationHash;
+        }
+
+        @Override
+        public Set<AnyVersionedMap> getDependingMaps() {
+                return Set.of(this.map);
+        }
+
+        public static <K, V> boolean sameSubNode(InOrderMapCursor<K, V> cursor1, InOrderMapCursor<K, V> cursor2) {
+                Node<K, V> nodeOfCursor1 = cursor1.nodeStack.peek();
+                Node<K, V> nodeOfCursor2 = cursor2.nodeStack.peek();
+                return Objects.equals(nodeOfCursor1, nodeOfCursor2);
+        }
+
+        /**
+         * Compares the state of two cursors started on two {@link VersionedMap} of the same
+         * {@link tools.refinery.store.map.VersionedMapStore}.
+         * @param <K> Key type
+         * @param <V> Value type
+         * @param cursor1 first cursor
+         * @param cursor2 second cursor
+         * @return Positive number if cursor 1 is behind, negative number if cursor 2 is behind, and 0 if they are at the
+         * same position.
+         */
+        public static <K, V> int comparePosition(InOrderMapCursor<K, V> cursor1, InOrderMapCursor<K, V> cursor2) {
+                // If the state does not determine the order, then compare @nodeIndexStack.
+                Iterator<Integer> nodeIndexStack1 = cursor1.nodeIndexStack.descendingIterator();
+                Iterator<Integer> nodeIndexStack2 = cursor2.nodeIndexStack.descendingIterator();
+
+                while(nodeIndexStack1.hasNext() && nodeIndexStack2.hasNext()){
+                        final int index1 = nodeIndexStack1.next();
+                        final int index2 = nodeIndexStack2.next();
+                        if(index1 < index2) {
+                                return 1;
+                        } else if(index1 > index2) {
+                                return -1;
+                        }
+                }
+
+                return 0;
+        }
+
+        /**
+         * Compares the depth of two cursors started on  @{@link VersionedMap} of the same
+         *        {@link tools.refinery.store.map.VersionedMapStore}.
+         * @param <K> Key type
+         * @param <V> Value type
+         * @param cursor1 first cursor
+         * @param cursor2 second cursor
+         * @return Positive number if cursor 1 is deeper, negative number if cursor 2 is deeper, and 0 if they are at the
+         *  same depth.
+         */
+        public static <K, V> int compareDepth(InOrderMapCursor<K, V> cursor1, InOrderMapCursor<K, V> cursor2) {
+                int d1 = cursor1.nodeIndexStack.size();
+                int d2 = cursor2.nodeIndexStack.size();
+                return Integer.compare(d1, d2);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapCursor.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/MapCursor.java
index f34ec7bb..0db50d04 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapCursor.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/MapCursor.java
@@ -1,9 +1,9 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.store.map.internal;
+package tools.refinery.store.map.internal.state;
 
 import tools.refinery.store.map.AnyVersionedMap;
 import tools.refinery.store.map.ContentHashCode;
@@ -12,7 +12,6 @@ import tools.refinery.store.map.VersionedMap;
 
 import java.util.ArrayDeque;
 import java.util.ConcurrentModificationException;
-import java.util.Iterator;
 import java.util.Set;
 
 public class MapCursor<K, V> implements Cursor<K, V> {
@@ -84,13 +83,6 @@ public class MapCursor<K, V> implements Cursor<K, V> {
                 return false;
         }
 
-        public boolean skipCurrentNode() {
-                nodeStack.pop();
-                nodeIndexStack.pop();
-                dataIndex = INDEX_FINISH;
-                return move();
-        }
-
         @Override
         public boolean isDirty() {
                 return this.map.contentHashCode(ContentHashCode.APPROXIMATE_FAST) != this.creationHash;
@@ -100,46 +92,4 @@ public class MapCursor<K, V> implements Cursor<K, V> {
         public Set<AnyVersionedMap> getDependingMaps() {
                 return Set.of(this.map);
         }
-
-        public static <K, V> boolean sameSubnode(MapCursor<K, V> cursor1, MapCursor<K, V> cursor2) {
-                Node<K, V> nodeOfCursor1 = cursor1.nodeStack.peek();
-                Node<K, V> nodeOfCursor2 = cursor2.nodeStack.peek();
-                if (nodeOfCursor1 != null && nodeOfCursor2 != null) {
-                        return nodeOfCursor1.equals(nodeOfCursor2);
-                } else {
-                        return false;
-                }
-        }
-
-        /**
-         * @param <K>
-         * @param <V>
-         * @param cursor1
-         * @param cursor2
-         * @return Positive number if cursor 1 is behind, negative number if cursor 2 is behind, and 0 if they are at the
-         * same position.
-         */
-        public static <K, V> int compare(MapCursor<K, V> cursor1, MapCursor<K, V> cursor2) {
-                // two cursors are equally deep
-                Iterator<Integer> stack1 = cursor1.nodeIndexStack.descendingIterator();
-                Iterator<Integer> stack2 = cursor2.nodeIndexStack.descendingIterator();
-                if (stack1.hasNext()) {
-                        if (!stack2.hasNext()) {
-                                // stack 2 has no more element, thus stack 1 is deeper
-                                return 1;
-                        }
-                        int val1 = stack1.next();
-                        int val2 = stack2.next();
-                        if (val1 < val2) {
-                                return -1;
-                        } else if (val2 < val1) {
-                                return 1;
-                        }
-                }
-                if (stack2.hasNext()) {
-                        // stack 2 has more element, thus stack 2 is deeper
-                        return 1;
-                }
-                return Integer.compare(cursor1.dataIndex, cursor2.dataIndex);
-        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/MapDiffCursor.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/MapDiffCursor.java
new file mode 100644
index 00000000..083bf8cf
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/MapDiffCursor.java
@@ -0,0 +1,264 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.state;
+
+import tools.refinery.store.map.AnyVersionedMap;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.DiffCursor;
+
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * A cursor representing the difference between two states of a map.
+ *
+ * @author Oszkar Semerath
+ */
+public class MapDiffCursor<K, V> implements DiffCursor<K, V>, Cursor<K, V> {
+        private enum State {
+                /**
+                 * initialized state.
+                 */
+                INIT,
+                /**
+                 * Unstable state.
+                 */
+                MOVING_MOVING_SAME_KEY_SAME_VALUE,
+                /**
+                 * Both cursors are moving, and they are on the same sub-node.
+                 */
+                MOVING_MOVING_SAME_NODE,
+                /**
+                 * Both cursors are moving, cursor 1 is behind.
+                 */
+                MOVING_MOVING_BEHIND1,
+                /**
+                 * Both cursors are moving, cursor 2 is behind.
+                 */
+                MOVING_MOVING_BEHIND2,
+                /**
+                 * Both cursors are moving, cursor 1 is on the same key as cursor 2, values are different
+                 */
+                MOVING_MOVING_SAME_KEY_DIFFERENT_VALUE,
+                /**
+                 * Cursor 1 is moving, Cursor 2 is terminated.
+                 */
+                MOVING_TERMINATED,
+                /**
+                 * Cursor 1 is terminated , Cursor 2 is moving.
+                 */
+                TERMINATED_MOVING,
+                /**
+                 * Both cursors are terminated.
+                 */
+                TERMINATED_TERMINATED,
+                /**
+                 * Both Cursors are moving, and they are on an incomparable position.
+                 * It is resolved by showing Cursor 1.
+                 */
+                MOVING_MOVING_HASH1,
+                /**
+                 * Both Cursors are moving, and they are on an incomparable position.
+                 * It is resolved by showing Cursor 2.
+                 */
+                MOVING_MOVING_HASH2
+        }
+
+        /**
+         * Default nodeId representing missing elements.
+         */
+        private final V defaultValue;
+        private final InOrderMapCursor<K, V> cursor1;
+        private final InOrderMapCursor<K, V> cursor2;
+
+        // State
+        State state = State.INIT;
+
+        // Values
+        private K key;
+        private V fromValue;
+        private V toValue;
+
+
+        public MapDiffCursor(V defaultValue, InOrderMapCursor<K, V> cursor1, InOrderMapCursor<K, V> cursor2) {
+                super();
+                this.defaultValue = defaultValue;
+                this.cursor1 = cursor1;
+                this.cursor2 = cursor2;
+        }
+
+        @Override
+        public K getKey() {
+                return key;
+        }
+
+        @Override
+        public V getFromValue() {
+                return fromValue;
+        }
+
+        @Override
+        public V getToValue() {
+                return toValue;
+        }
+
+        @Override
+        public V getValue() {
+                return getToValue();
+        }
+
+        public boolean isTerminated() {
+                return this.state == State.TERMINATED_TERMINATED;
+        }
+
+        @Override
+        public boolean isDirty() {
+                return this.cursor1.isDirty() || this.cursor2.isDirty();
+        }
+
+        @Override
+        public Set<AnyVersionedMap> getDependingMaps() {
+                return Stream.concat(cursor1.getDependingMaps().stream(), cursor2.getDependingMaps().stream()).map(AnyVersionedMap.class::cast).collect(Collectors.toUnmodifiableSet());
+        }
+
+        private boolean isInStableState() {
+                return this.state != State.MOVING_MOVING_SAME_KEY_SAME_VALUE
+                                && this.state != State.MOVING_MOVING_SAME_NODE && this.state != State.INIT;
+        }
+
+        private boolean updateAndReturnWithResult() {
+                return switch (this.state) {
+                        case INIT -> throw new IllegalStateException("DiffCursor terminated without starting!");
+                        case MOVING_MOVING_SAME_KEY_SAME_VALUE, MOVING_MOVING_SAME_NODE ->
+                                        throw new IllegalStateException("DiffCursor terminated in unstable state!");
+                        case MOVING_MOVING_BEHIND1, MOVING_TERMINATED, MOVING_MOVING_HASH1 -> {
+                                this.key = this.cursor1.getKey();
+                                this.fromValue = this.cursor1.getValue();
+                                this.toValue = this.defaultValue;
+                                yield true;
+                        }
+                        case MOVING_MOVING_BEHIND2, TERMINATED_MOVING, MOVING_MOVING_HASH2 -> {
+                                this.key = this.cursor2.getKey();
+                                this.fromValue = this.defaultValue;
+                                this.toValue = cursor2.getValue();
+                                yield true;
+                        }
+                        case MOVING_MOVING_SAME_KEY_DIFFERENT_VALUE -> {
+                                this.key = this.cursor1.getKey();
+                                this.fromValue = this.cursor1.getValue();
+                                this.toValue = this.cursor2.getValue();
+                                yield true;
+                        }
+                        case TERMINATED_TERMINATED -> {
+                                this.key = null;
+                                this.fromValue = null;
+                                this.toValue = null;
+                                yield false;
+                        }
+                };
+        }
+
+        public boolean move() {
+                do {
+                        this.state = moveOne(this.state);
+                } while (!isInStableState());
+                return updateAndReturnWithResult();
+        }
+
+        private State moveOne(State currentState) {
+                return switch (currentState) {
+                        case INIT, MOVING_MOVING_HASH2, MOVING_MOVING_SAME_KEY_SAME_VALUE, MOVING_MOVING_SAME_KEY_DIFFERENT_VALUE -> {
+                                boolean cursor1Moved = cursor1.move();
+                                boolean cursor2Moved = cursor2.move();
+                                yield recalculateStateAfterCursorMovement(cursor1Moved, cursor2Moved);
+                        }
+                        case MOVING_MOVING_SAME_NODE -> {
+                                boolean cursor1Moved = cursor1.skipCurrentNode();
+                                boolean cursor2Moved = cursor2.skipCurrentNode();
+                                yield recalculateStateAfterCursorMovement(cursor1Moved, cursor2Moved);
+                        }
+                        case MOVING_MOVING_BEHIND1 -> {
+                                boolean cursorMoved = cursor1.move();
+                                if (cursorMoved) {
+                                        yield recalculateStateBasedOnCursorRelation();
+                                } else {
+                                        yield State.TERMINATED_MOVING;
+                                }
+                        }
+                        case MOVING_MOVING_BEHIND2 -> {
+                                boolean cursorMoved = cursor2.move();
+                                if (cursorMoved) {
+                                        yield recalculateStateBasedOnCursorRelation();
+                                } else {
+                                        yield State.MOVING_TERMINATED;
+                                }
+                        }
+                        case TERMINATED_MOVING -> {
+                                boolean cursorMoved = cursor2.move();
+                                if (cursorMoved) {
+                                        yield State.TERMINATED_MOVING;
+                                } else {
+                                        yield State.TERMINATED_TERMINATED;
+                                }
+                        }
+                        case MOVING_TERMINATED -> {
+                                boolean cursorMoved = cursor1.move();
+                                if (cursorMoved) {
+                                        yield State.MOVING_TERMINATED;
+                                } else {
+                                        yield State.TERMINATED_TERMINATED;
+                                }
+                        }
+                        case MOVING_MOVING_HASH1 -> State.MOVING_MOVING_HASH2;
+                        case TERMINATED_TERMINATED -> throw new IllegalStateException("Trying to move while terminated!");
+                };
+        }
+
+        private State recalculateStateAfterCursorMovement(boolean cursor1Moved, boolean cursor2Moved) {
+                if (cursor1Moved && cursor2Moved) {
+                        return recalculateStateBasedOnCursorRelation();
+                } else if (cursor1Moved) {
+                        return State.MOVING_TERMINATED;
+                } else if (cursor2Moved) {
+                        return State.TERMINATED_MOVING;
+                } else {
+                        return State.TERMINATED_TERMINATED;
+                }
+        }
+
+        private State recalculateStateBasedOnCursorRelation() {
+                final int relation = InOrderMapCursor.comparePosition(cursor1, cursor2);
+
+                if (relation > 0) {
+                        return State.MOVING_MOVING_BEHIND1;
+                } else if (relation < 0) {
+                        return State.MOVING_MOVING_BEHIND2;
+                }
+
+                if (InOrderMapCursor.sameSubNode(cursor1, cursor2)) {
+                        return State.MOVING_MOVING_SAME_NODE;
+                } else if (Objects.equals(cursor1.getKey(), cursor2.getKey())) {
+                        if (Objects.equals(cursor1.getValue(), cursor2.getValue())) {
+                                return State.MOVING_MOVING_SAME_KEY_SAME_VALUE;
+                        } else {
+                                return State.MOVING_MOVING_SAME_KEY_DIFFERENT_VALUE;
+                        }
+                }
+
+                final int depth = InOrderMapCursor.compareDepth(cursor1, cursor2);
+
+                if (depth > 0) {
+                        return State.MOVING_MOVING_BEHIND1;
+                } else if (depth < 0) {
+                        return State.MOVING_MOVING_BEHIND2;
+                } else {
+                        return State.MOVING_MOVING_HASH1;
+                }
+
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MutableNode.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/MutableNode.java
index 1129ee5a..408ed62c 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MutableNode.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/MutableNode.java
@@ -1,26 +1,26 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.store.map.internal;
+package tools.refinery.store.map.internal.state;
 
-import tools.refinery.store.map.ContinousHashProvider;
+import tools.refinery.store.map.ContinuousHashProvider;
 
 import java.util.Arrays;
 import java.util.Map;
 
 public class MutableNode<K, V> extends Node<K, V> {
         int cachedHash;
+        protected boolean cachedHashValid;
         protected Object[] content;
 
         protected MutableNode() {
                 this.content = new Object[2 * FACTOR];
-                updateHash();
+                invalidateHash();
         }
 
-        public static <K, V> MutableNode<K, V> initialize(K key, V value, ContinousHashProvider<? super K> hashProvider,
-                        V defaultValue) {
+        public static <K, V> MutableNode<K, V> initialize(K key, V value, ContinuousHashProvider<? super K> hashProvider, V defaultValue) {
                 if (value == defaultValue) {
                         return null;
                 } else {
@@ -29,7 +29,7 @@ public class MutableNode<K, V> extends Node<K, V> {
                         MutableNode<K, V> res = new MutableNode<>();
                         res.content[2 * fragment] = key;
                         res.content[2 * fragment + 1] = value;
-                        res.updateHash();
+                        res.invalidateHash();
                         return res;
                 }
         }
@@ -37,44 +37,41 @@ public class MutableNode<K, V> extends Node<K, V> {
         /**
          * Constructs a {@link MutableNode} as a copy of an {@link ImmutableNode}
          *
-         * @param node
+         * @param node to be transformed
          */
         protected MutableNode(ImmutableNode<K, V> node) {
                 this.content = new Object[2 * FACTOR];
                 int dataUsed = 0;
                 int nodeUsed = 0;
                 for (int i = 0; i < FACTOR; i++) {
-                        int bitposition = 1 << i;
-                        if ((node.dataMap & bitposition) != 0) {
+                        int bitPosition = 1 << i;
+                        if ((node.dataMap & bitPosition) != 0) {
                                 content[2 * i] = node.content[dataUsed * 2];
                                 content[2 * i + 1] = node.content[dataUsed * 2 + 1];
                                 dataUsed++;
-                        } else if ((node.nodeMap & bitposition) != 0) {
+                        } else if ((node.nodeMap & bitPosition) != 0) {
                                 content[2 * i + 1] = node.content[node.content.length - 1 - nodeUsed];
                                 nodeUsed++;
                         }
                 }
-                this.cachedHash = node.hashCode();
+                this.cachedHashValid = false;
         }
 
         @Override
-        public V getValue(K key, ContinousHashProvider<? super K> hashProvider, V defaultValue, int hash, int depth) {
+        public V getValue(K key, ContinuousHashProvider<? super K> hashProvider, V defaultValue, int hash, int depth) {
                 int selectedHashFragment = hashFragment(hash, shiftDepth(depth));
-                @SuppressWarnings("unchecked")
-                K keyCandidate = (K) this.content[2 * selectedHashFragment];
+                @SuppressWarnings("unchecked") K keyCandidate = (K) this.content[2 * selectedHashFragment];
                 if (keyCandidate != null) {
                         if (keyCandidate.equals(key)) {
-                                @SuppressWarnings("unchecked")
-                                V value = (V) this.content[2 * selectedHashFragment + 1];
+                                @SuppressWarnings("unchecked") V value = (V) this.content[2 * selectedHashFragment + 1];
                                 return value;
                         } else {
                                 return defaultValue;
                         }
                 } else {
-                        @SuppressWarnings("unchecked")
-                        var nodeCandidate = (Node<K, V>) content[2 * selectedHashFragment + 1];
+                        @SuppressWarnings("unchecked") var nodeCandidate = (Node<K, V>) content[2 * selectedHashFragment + 1];
                         if (nodeCandidate != null) {
-                                int newDepth = depth + 1;
+                                int newDepth = incrementDepth(depth);
                                 int newHash = newHash(hashProvider, key, hash, newDepth);
                                 return nodeCandidate.getValue(key, hashProvider, defaultValue, newHash, newDepth);
                         } else {
@@ -84,13 +81,11 @@ public class MutableNode<K, V> extends Node<K, V> {
         }
 
         @Override
-        public Node<K, V> putValue(K key, V value, OldValueBox<V> oldValueBox, ContinousHashProvider<? super K> hashProvider,
-                        V defaultValue, int hash, int depth) {
+        public Node<K, V> putValue(K key, V value, OldValueBox<V> oldValueBox, ContinuousHashProvider<? super K> hashProvider, V defaultValue, int hash, int depth) {
                 int selectedHashFragment = hashFragment(hash, shiftDepth(depth));
-                @SuppressWarnings("unchecked")
-                K keyCandidate = (K) content[2 * selectedHashFragment];
+                @SuppressWarnings("unchecked") K keyCandidate = (K) content[2 * selectedHashFragment];
                 if (keyCandidate != null) {
-                        // If has key
+                        // If it has key
                         if (keyCandidate.equals(key)) {
                                 // The key is equals to an existing key -> update entry
                                 if (value == defaultValue) {
@@ -111,25 +106,22 @@ public class MutableNode<K, V> extends Node<K, V> {
                                         return moveDownAndSplit(hashProvider, key, value, keyCandidate, hash, depth, selectedHashFragment);
                                 }
                         }
+                }
+                // If it does not have key, check for value
+                @SuppressWarnings("unchecked") var nodeCandidate = (Node<K, V>) content[2 * selectedHashFragment + 1];
+                if (nodeCandidate != null) {
+                        // If it has value, it is a sub-node -> update that
+                        int newDepth = incrementDepth(depth);
+                        var newNode = nodeCandidate.putValue(key, value, oldValueBox, hashProvider, defaultValue, newHash(hashProvider, key, hash, newDepth), newDepth);
+                        return updateWithSubNode(selectedHashFragment, newNode, (value == null && defaultValue == null) || (value != null && value.equals(defaultValue)));
                 } else {
-                        // If it does not have key, check for nodeId
-                        @SuppressWarnings("unchecked")
-                        var nodeCandidate = (Node<K, V>) content[2 * selectedHashFragment + 1];
-                        if (nodeCandidate != null) {
-                                // If it has nodeId, it is a subnode -> upate that
-                                var newNode = nodeCandidate.putValue(key, value, oldValueBox, hashProvider, defaultValue,
-                                                newHash(hashProvider, key, hash, depth + 1), depth + 1);
-                                return updateWithSubNode(selectedHashFragment, newNode, value.equals(defaultValue));
+                        // If it does not have value, put it in the empty place
+                        if (value == defaultValue) {
+                                // don't need to add new key-value pair
+                                oldValueBox.setOldValue(defaultValue);
+                                return this;
                         } else {
-                                // If it does not have nodeId, put it in the empty place
-                                if (value == defaultValue) {
-                                        // dont need to add new key-nodeId pair
-                                        oldValueBox.setOldValue(defaultValue);
-                                        return this;
-                                } else {
-                                        return addEntry(key, value, oldValueBox, selectedHashFragment, defaultValue);
-                                }
-
+                                return addEntry(key, value, oldValueBox, selectedHashFragment, defaultValue);
                         }
                 }
         }
@@ -138,30 +130,31 @@ public class MutableNode<K, V> extends Node<K, V> {
                 content[2 * selectedHashFragment] = key;
                 oldValueBox.setOldValue(defaultValue);
                 content[2 * selectedHashFragment + 1] = value;
-                updateHash();
+                invalidateHash();
                 return this;
         }
 
         /**
-         * Updates an entry in a selected hash-fragment to a non-default nodeId.
+         * Updates an entry in a selected hash-fragment to a non-default value.
          *
-         * @param value
-         * @param selectedHashFragment
-         * @return
+         * @param value new value
+         * @param selectedHashFragment position of the value
+         * @return updated node
          */
         @SuppressWarnings("unchecked")
         Node<K, V> updateValue(V value, OldValueBox<V> oldValue, int selectedHashFragment) {
                 oldValue.setOldValue((V) content[2 * selectedHashFragment + 1]);
                 content[2 * selectedHashFragment + 1] = value;
-                updateHash();
+                invalidateHash();
                 return this;
         }
 
         /**
+         * Updates an entry in a selected hash-fragment with a subtree.
          *
-         * @param selectedHashFragment
-         * @param newNode
-         * @return
+         * @param selectedHashFragment position of the value
+         * @param newNode the subtree
+         * @return updated node
          */
         Node<K, V> updateWithSubNode(int selectedHashFragment, Node<K, V> newNode, boolean deletionHappened) {
                 if (deletionHappened) {
@@ -169,7 +162,7 @@ public class MutableNode<K, V> extends Node<K, V> {
                                 // Check whether this node become empty
                                 content[2 * selectedHashFragment + 1] = null; // i.e. the new node
                                 if (hasContent()) {
-                                        updateHash();
+                                        invalidateHash();
                                         return this;
                                 } else {
                                         return null;
@@ -180,10 +173,10 @@ public class MutableNode<K, V> extends Node<K, V> {
                                 if (immutableNewNode != null) {
                                         int orphaned = immutableNewNode.isOrphaned();
                                         if (orphaned >= 0) {
-                                                // orphan subnode data is replaced with data
+                                                // orphan sub-node data is replaced with data
                                                 content[2 * selectedHashFragment] = immutableNewNode.content[orphaned * 2];
                                                 content[2 * selectedHashFragment + 1] = immutableNewNode.content[orphaned * 2 + 1];
-                                                updateHash();
+                                                invalidateHash();
                                                 return this;
                                         }
                                 }
@@ -191,15 +184,13 @@ public class MutableNode<K, V> extends Node<K, V> {
                 }
                 // normal behaviour
                 content[2 * selectedHashFragment + 1] = newNode;
-                updateHash();
+                invalidateHash();
                 return this;
-
         }
 
         private boolean hasContent() {
                 for (Object element : this.content) {
-                        if (element != null)
-                                return true;
+                        if (element != null) return true;
                 }
                 return false;
         }
@@ -226,27 +217,24 @@ public class MutableNode<K, V> extends Node<K, V> {
         }
 
         @SuppressWarnings("unchecked")
-        private Node<K, V> moveDownAndSplit(ContinousHashProvider<? super K> hashProvider, K newKey, V newValue,
-                        K previousKey, int hashOfNewKey, int depth, int selectedHashFragmentOfCurrentDepth) {
+        private Node<K, V> moveDownAndSplit(ContinuousHashProvider<? super K> hashProvider, K newKey, V newValue, K previousKey, int hashOfNewKey, int depth, int selectedHashFragmentOfCurrentDepth) {
                 V previousValue = (V) content[2 * selectedHashFragmentOfCurrentDepth + 1];
 
-                MutableNode<K, V> newSubNode = newNodeWithTwoEntries(hashProvider, previousKey, previousValue,
-                                hashProvider.getHash(previousKey, hashDepth(depth)), newKey, newValue, hashOfNewKey, depth + 1);
+                MutableNode<K, V> newSubNode = newNodeWithTwoEntries(hashProvider, previousKey, previousValue, hashProvider.getHash(previousKey, hashDepth(depth)), newKey, newValue, hashOfNewKey, incrementDepth(depth));
 
                 content[2 * selectedHashFragmentOfCurrentDepth] = null;
                 content[2 * selectedHashFragmentOfCurrentDepth + 1] = newSubNode;
-                updateHash();
+                invalidateHash();
                 return this;
         }
 
         // Pass everything as parameters for performance.
         @SuppressWarnings("squid:S107")
-        private MutableNode<K, V> newNodeWithTwoEntries(ContinousHashProvider<? super K> hashProvider, K key1, V value1,
-                        int oldHash1, K key2, V value2, int oldHash2, int newdepth) {
-                int newHash1 = newHash(hashProvider, key1, oldHash1, newdepth);
-                int newHash2 = newHash(hashProvider, key2, oldHash2, newdepth);
-                int newFragment1 = hashFragment(newHash1, shiftDepth(newdepth));
-                int newFragment2 = hashFragment(newHash2, shiftDepth(newdepth));
+        private MutableNode<K, V> newNodeWithTwoEntries(ContinuousHashProvider<? super K> hashProvider, K key1, V value1, int oldHash1, K key2, V value2, int oldHash2, int newDepth) {
+                int newHash1 = newHash(hashProvider, key1, oldHash1, newDepth);
+                int newHash2 = newHash(hashProvider, key2, oldHash2, newDepth);
+                int newFragment1 = hashFragment(newHash1, shiftDepth(newDepth));
+                int newFragment2 = hashFragment(newHash2, shiftDepth(newDepth));
 
                 MutableNode<K, V> subNode = new MutableNode<>();
                 if (newFragment1 != newFragment2) {
@@ -256,11 +244,10 @@ public class MutableNode<K, V> extends Node<K, V> {
                         subNode.content[newFragment2 * 2] = key2;
                         subNode.content[newFragment2 * 2 + 1] = value2;
                 } else {
-                        MutableNode<K, V> subSubNode = newNodeWithTwoEntries(hashProvider, key1, value1, newHash1, key2, value2,
-                                        newHash2, newdepth + 1);
+                        MutableNode<K, V> subSubNode = newNodeWithTwoEntries(hashProvider, key1, value1, newHash1, key2, value2, newHash2, incrementDepth(newDepth));
                         subNode.content[newFragment1 * 2 + 1] = subSubNode;
                 }
-                subNode.updateHash();
+                subNode.invalidateHash();
                 return subNode;
         }
 
@@ -270,7 +257,7 @@ public class MutableNode<K, V> extends Node<K, V> {
                 oldValue.setOldValue((V) content[2 * selectedHashFragment + 1]);
                 content[2 * selectedHashFragment + 1] = null;
                 if (hasContent()) {
-                        updateHash();
+                        invalidateHash();
                         return this;
                 } else {
                         return null;
@@ -321,10 +308,13 @@ public class MutableNode<K, V> extends Node<K, V> {
                         cursor.dataIndex = MapCursor.INDEX_FINISH;
                 }
 
-                // 2. look inside the subnodes
+                // 2. look inside the sub-nodes
+                if(cursor.nodeIndexStack.peek()==null) {
+                        throw new IllegalStateException("Cursor moved to the next state when the state is empty.");
+                }
                 for (int index = cursor.nodeIndexStack.peek() + 1; index < FACTOR; index++) {
                         if (this.content[index * 2] == null && this.content[index * 2 + 1] != null) {
-                                // 2.1 found next subnode, move down to the subnode
+                                // 2.1 found next sub-node, move down to the sub-node
                                 Node<K, V> subnode = (Node<K, V>) this.content[index * 2 + 1];
 
                                 cursor.dataIndex = MapCursor.INDEX_START;
@@ -336,7 +326,7 @@ public class MutableNode<K, V> extends Node<K, V> {
                                 return subnode.moveToNext(cursor);
                         }
                 }
-                // 3. no subnode found, move up
+                // 3. no sub-node found, move up
                 cursor.nodeStack.pop();
                 cursor.nodeIndexStack.pop();
                 if (!cursor.nodeStack.isEmpty()) {
@@ -350,10 +340,51 @@ public class MutableNode<K, V> extends Node<K, V> {
         }
 
         @Override
-        public void prettyPrint(StringBuilder builder, int depth, int code) {
-                for (int i = 0; i < depth; i++) {
-                        builder.append("\t");
+        @SuppressWarnings("unchecked")
+        boolean moveToNextInorder(InOrderMapCursor<K,V> cursor) {
+                if(cursor.nodeIndexStack.peek()==null || cursor.nodeStack.peek()==null) {
+                        throw new IllegalStateException("Cursor moved to the next state when the state is empty.");
                 }
+
+                int position = cursor.nodeIndexStack.peek();
+
+                for (int index = position + 1; index < FACTOR; index++) {
+                        // data found
+                        if (this.content[index * 2] != null) {
+                                cursor.nodeIndexStack.pop();
+                                cursor.nodeIndexStack.push(index);
+
+                                cursor.key = (K) this.content[index * 2];
+                                cursor.value = (V) this.content[index * 2 + 1];
+                                return true;
+                        } else if (this.content[index * 2 +1] != null) {
+                                // sub-node found
+                                Node<K,V> subnode = (Node<K, V>) this.content[index * 2 +1];
+                                cursor.nodeIndexStack.pop();
+                                cursor.nodeIndexStack.push(index);
+                                cursor.nodeIndexStack.push(InOrderMapCursor.INDEX_START);
+                                cursor.nodeStack.push(subnode);
+
+                                return subnode.moveToNextInorder(cursor);
+                        }
+                }
+
+                // nothing found
+                cursor.nodeStack.pop();
+                cursor.nodeIndexStack.pop();
+                if (!cursor.nodeStack.isEmpty()) {
+                        Node<K, V> supernode = cursor.nodeStack.peek();
+                        return supernode.moveToNextInorder(cursor);
+                } else {
+                        cursor.key = null;
+                        cursor.value = null;
+                        return false;
+                }
+        }
+
+        @Override
+        public void prettyPrint(StringBuilder builder, int depth, int code) {
+                builder.append("\t".repeat(Math.max(0, depth)));
                 if (code >= 0) {
                         builder.append(code);
                         builder.append(":");
@@ -376,19 +407,18 @@ public class MutableNode<K, V> extends Node<K, V> {
                         }
                 }
                 builder.append(")");
-                // print subnodes
+                // print sub-nodes
                 for (int i = 0; i < FACTOR; i++) {
                         if (content[2 * i] == null && content[2 * i + 1] != null) {
-                                @SuppressWarnings("unchecked")
-                                Node<K, V> subNode = (Node<K, V>) content[2 * i + 1];
+                                @SuppressWarnings("unchecked") Node<K, V> subNode = (Node<K, V>) content[2 * i + 1];
                                 builder.append("\n");
-                                subNode.prettyPrint(builder, depth + 1, i);
+                                subNode.prettyPrint(builder, incrementDepth(depth), i);
                         }
                 }
         }
 
         @Override
-        public void checkIntegrity(ContinousHashProvider<? super K> hashProvider, V defaultValue, int depth) {
+        public void checkIntegrity(ContinuousHashProvider<? super K> hashProvider, V defaultValue, int depth) {
                 // check for orphan nodes
                 if (depth > 0) {
                         int orphaned = isOrphaned();
@@ -399,57 +429,67 @@ public class MutableNode<K, V> extends Node<K, V> {
                 // check the place of data
                 for (int i = 0; i < FACTOR; i++) {
                         if (this.content[2 * i] != null) {
-                                @SuppressWarnings("unchecked")
-                                K key = (K) this.content[2 * i];
-                                @SuppressWarnings("unchecked")
-                                V value = (V) this.content[2 * i + 1];
+                                @SuppressWarnings("unchecked") K key = (K) this.content[2 * i];
+                                @SuppressWarnings("unchecked") V value = (V) this.content[2 * i + 1];
 
                                 if (value == defaultValue) {
-                                        throw new IllegalStateException("Node contains default nodeId!");
+                                        throw new IllegalStateException("Node contains default value!");
                                 }
                                 int hashCode = hashProvider.getHash(key, hashDepth(depth));
                                 int shiftDepth = shiftDepth(depth);
                                 int selectedHashFragment = hashFragment(hashCode, shiftDepth);
                                 if (i != selectedHashFragment) {
-                                        throw new IllegalStateException("Key " + key + " with hash code " + hashCode
-                                                        + " is in bad place! Fragment=" + selectedHashFragment + ", Place=" + i);
+                                        throw new IllegalStateException("Key " + key + " with hash code " + hashCode + " is in bad place! Fragment=" + selectedHashFragment + ", Place=" + i);
                                 }
                         }
                 }
-                // check subnodes
+                // check sub-nodes
                 for (int i = 0; i < FACTOR; i++) {
                         if (this.content[2 * i + 1] != null && this.content[2 * i] == null) {
-                                @SuppressWarnings("unchecked")
-                                var subNode = (Node<K, V>) this.content[2 * i + 1];
-                                subNode.checkIntegrity(hashProvider, defaultValue, depth + 1);
+                                @SuppressWarnings("unchecked") var subNode = (Node<K, V>) this.content[2 * i + 1];
+                                subNode.checkIntegrity(hashProvider, defaultValue, incrementDepth(depth));
                         }
                 }
                 // check the hash
-                int oldHash = this.cachedHash;
-                updateHash();
-                int newHash = this.cachedHash;
-                if (oldHash != newHash) {
-                        throw new IllegalStateException("Hash code was not up to date! (old=" + oldHash + ",new=" + newHash + ")");
+                if (cachedHashValid) {
+                        int oldHash = this.cachedHash;
+                        invalidateHash();
+                        int newHash = hashCode();
+                        if (oldHash != newHash) {
+                                throw new IllegalStateException("Hash code was not up to date! (old=" + oldHash + ",new=" + newHash + ")");
+                        }
                 }
         }
 
-        protected void updateHash() {
-                this.cachedHash = Arrays.hashCode(content);
+        protected void invalidateHash() {
+                this.cachedHashValid = false;
         }
 
         @Override
         public int hashCode() {
+                if (!this.cachedHashValid) {
+                        this.cachedHash = Arrays.hashCode(content);
+                        this.cachedHashValid = true;
+                }
                 return this.cachedHash;
         }
 
         @Override
         public boolean equals(Object obj) {
-                if (this == obj)
-                        return true;
-                if (obj == null)
-                        return false;
+                if (this == obj) return true;
+                if (obj == null) return false;
                 if (obj instanceof MutableNode<?, ?> mutableObj) {
-                        return Arrays.deepEquals(this.content, mutableObj.content);
+                        if (obj.hashCode() != this.hashCode()) {
+                                return false;
+                        } else {
+                                for (int i = 0; i < FACTOR * 2; i++) {
+                                        Object thisContent = this.content[i];
+                                        if (thisContent != null && !thisContent.equals(mutableObj.content[i])) {
+                                                return false;
+                                        }
+                                }
+                                return true;
+                        }
                 } else if (obj instanceof ImmutableNode<?, ?> immutableObj) {
                         return ImmutableNode.compareImmutableMutable(immutableObj, this);
                 } else {
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/Node.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/Node.java
new file mode 100644
index 00000000..0ecf2712
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/Node.java
@@ -0,0 +1,131 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.state;
+
+import java.util.Map;
+
+import tools.refinery.store.map.ContinuousHashProvider;
+
+public abstract class Node<K, V> {
+        public static final int BRANCHING_FACTOR_BITS = 5;
+        public static final int FACTOR = 1 << BRANCHING_FACTOR_BITS;
+        protected static final int NUMBER_OF_FACTORS = Integer.SIZE / BRANCHING_FACTOR_BITS;
+        protected static final int FACTOR_MASK = FACTOR - 1;
+        public static final int EFFECTIVE_BITS = BRANCHING_FACTOR_BITS * NUMBER_OF_FACTORS;
+        public static final int FACTOR_SELECTION_BITS = 32 - Integer.numberOfLeadingZeros(NUMBER_OF_FACTORS);
+        public static final int FACTOR_SELECTION_MASK = (1 << FACTOR_SELECTION_BITS) - 1;
+        public static final int INCREMENT_BIG_STEP = (1 << FACTOR_SELECTION_BITS) - NUMBER_OF_FACTORS;
+
+        /**
+         * Increments the depth of the search in the tree. The depth parameter has two
+         * components: the least few bits selects the fragment of the hashcode, the
+         * other part selects the continuous hash.
+         *
+         * @param depth parameter encoding the fragment and the depth
+         * @return new depth.
+         */
+        protected int incrementDepth(int depth) {
+                int newDepth = depth + 1;
+                if ((newDepth & FACTOR_SELECTION_MASK) == NUMBER_OF_FACTORS) {
+                        newDepth += INCREMENT_BIG_STEP;
+                }
+                return newDepth;
+        }
+
+        /**
+         * Calculates the index for the continuous hash.
+         *
+         * @param depth The depth of the node in the tree.
+         * @return The index of the continuous hash.
+         */
+        protected static int hashDepth(int depth) {
+                return depth >> FACTOR_SELECTION_BITS;
+        }
+
+        /**
+         * Calculates the which segment of a single hash should be used.
+         *
+         * @param depth The depth of the node in the tree.
+         * @return The segment of a hash code.
+         */
+        protected static int shiftDepth(int depth) {
+                return depth & FACTOR_SELECTION_MASK;
+        }
+
+        /**
+         * Selects a segments from a complete hash for a given depth.
+         *
+         * @param hash       A complete hash.
+         * @param shiftDepth The index of the segment.
+         * @return The segment as an integer.
+         */
+        protected static int hashFragment(int hash, int shiftDepth) {
+                if (shiftDepth < 0 || Node.NUMBER_OF_FACTORS < shiftDepth)
+                        throw new IllegalArgumentException("Invalid shift depth! valid interval=[0;5], input=" + shiftDepth);
+                return (hash >>> shiftDepth * BRANCHING_FACTOR_BITS) & FACTOR_MASK;
+        }
+
+        /**
+         * Returns the hash code for a given depth. It may calculate new hash code, or
+         * reuse a hash code calculated for depth-1.
+         *
+         * @param key   The key.
+         * @param hash  Hash code for depth-1
+         * @param depth The depth.
+         * @return The new hash code.
+         */
+        protected int newHash(final ContinuousHashProvider<? super K> hashProvider, K key, int hash, int depth) {
+                final int shiftDepth = shiftDepth(depth);
+                if (shiftDepth == 0) {
+                        final int hashDepth = hashDepth(depth);
+                        if (hashDepth >= ContinuousHashProvider.MAX_PRACTICAL_DEPTH) {
+                                throw new IllegalArgumentException(
+                                                "Key " + key + " have the clashing hashcode over the practical depth limitation ("
+                                                                + ContinuousHashProvider.MAX_PRACTICAL_DEPTH + ")!");
+                        }
+                        return hashProvider.getHash(key, hashDepth);
+                } else {
+                        return hash;
+                }
+        }
+
+        public abstract V getValue(K key, ContinuousHashProvider<? super K> hashProvider, V defaultValue, int hash,
+                                                           int depth);
+
+        public abstract Node<K, V> putValue(K key, V value, OldValueBox<V> old,
+                                                                                ContinuousHashProvider<? super K> hashProvider, V defaultValue, int hash, int depth);
+
+        public abstract long getSize();
+
+        abstract MutableNode<K, V> toMutable();
+
+        public abstract ImmutableNode<K, V> toImmutable(Map<Node<K, V>, ImmutableNode<K, V>> cache);
+
+        protected abstract MutableNode<K, V> isMutable();
+
+        /**
+         * Moves a {@link MapCursor} to its next position.
+         *
+         * @param cursor the cursor
+         * @return Whether there was a next value to move on.
+         */
+        abstract boolean moveToNext(MapCursor<K, V> cursor);
+        abstract boolean moveToNextInorder(InOrderMapCursor<K, V> cursor);
+
+        ///////// FOR printing
+        public abstract void prettyPrint(StringBuilder builder, int depth, int code);
+
+
+        @Override
+        public String toString() {
+                StringBuilder stringBuilder = new StringBuilder();
+                prettyPrint(stringBuilder, 0, -1);
+                return stringBuilder.toString();
+        }
+
+        public void checkIntegrity(ContinuousHashProvider<? super K> hashProvider, V defaultValue, int depth) {
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/OldValueBox.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/OldValueBox.java
index 354af51d..1b0a4b0c 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/OldValueBox.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/OldValueBox.java
@@ -1,9 +1,9 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.store.map.internal;
+package tools.refinery.store.map.internal.state;
 
 public class OldValueBox<V>{
         V oldValue;
@@ -20,5 +20,5 @@ public class OldValueBox<V>{
                 this.oldValue = ouldValue;
                 isSet = true;
         }
-        
+
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/StateBasedVersionedMapStoreFactory.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/StateBasedVersionedMapStoreFactory.java
new file mode 100644
index 00000000..ccc791a8
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/StateBasedVersionedMapStoreFactory.java
@@ -0,0 +1,43 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.state;
+
+import tools.refinery.store.map.*;
+
+import java.util.List;
+
+public class StateBasedVersionedMapStoreFactory<K, V> implements VersionedMapStoreFactory<K, V> {
+        private final V defaultValue;
+        private final ContinuousHashProvider<K> continuousHashProvider;
+        private final VersionedMapStoreStateConfiguration config;
+
+        public StateBasedVersionedMapStoreFactory(V defaultValue, Boolean transformToImmutable,
+                                                                                          VersionedMapStoreFactoryBuilder.SharingStrategy sharingStrategy,
+                                                                                          boolean versionFreeingEnabled,
+                                                                                          ContinuousHashProvider<K> continuousHashProvider) {
+                this.defaultValue = defaultValue;
+                this.continuousHashProvider = continuousHashProvider;
+
+                this.config = new VersionedMapStoreStateConfiguration(
+                                transformToImmutable,
+                                sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE
+                                                || sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE_IN_GROUP,
+                                sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE_IN_GROUP,
+                                versionFreeingEnabled);
+        }
+
+        @Override
+        public VersionedMapStore<K, V> createOne() {
+                return new VersionedMapStoreStateImpl<>(continuousHashProvider, defaultValue, config);
+
+        }
+
+        @Override
+        public List<VersionedMapStore<K, V>> createGroup(int amount) {
+                return VersionedMapStoreStateImpl.createSharedVersionedMapStores(amount, continuousHashProvider, defaultValue,
+                                config);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStateImpl.java
index 7abece0d..57eeccf6 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStateImpl.java
@@ -1,9 +1,9 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.store.map.internal;
+package tools.refinery.store.map.internal.state;
 
 import tools.refinery.store.map.*;
 
@@ -19,19 +19,18 @@ import java.util.Objects;
  * @param <V>
  * @author Oszkar Semerath
  */
-public class VersionedMapImpl<K, V> implements VersionedMap<K, V> {
-        protected final VersionedMapStoreImpl<K, V> store;
-
-        protected final ContinousHashProvider<K> hashProvider;
+public class VersionedMapStateImpl<K, V> implements VersionedMap<K, V> {
+        protected final VersionedMapStoreStateImpl<K, V> store;
 
+        protected final ContinuousHashProvider<K> hashProvider;
         protected final V defaultValue;
         protected Node<K, V> root;
 
         private final OldValueBox<V> oldValueBox = new OldValueBox<>();
 
-        public VersionedMapImpl(
-                        VersionedMapStoreImpl<K, V> store,
-                        ContinousHashProvider<K> hashProvider,
+        public VersionedMapStateImpl(
+                        VersionedMapStoreStateImpl<K, V> store,
+                        ContinuousHashProvider<K> hashProvider,
                         V defaultValue) {
                 this.store = store;
                 this.hashProvider = hashProvider;
@@ -39,9 +38,9 @@ public class VersionedMapImpl<K, V> implements VersionedMap<K, V> {
                 this.root = null;
         }
 
-        public VersionedMapImpl(
-                        VersionedMapStoreImpl<K, V> store,
-                        ContinousHashProvider<K> hashProvider,
+        public VersionedMapStateImpl(
+                        VersionedMapStoreStateImpl<K, V> store,
+                        ContinuousHashProvider<K> hashProvider,
                         V defaultValue, Node<K, V> data) {
                 this.store = store;
                 this.hashProvider = hashProvider;
@@ -49,11 +48,12 @@ public class VersionedMapImpl<K, V> implements VersionedMap<K, V> {
                 this.root = data;
         }
 
+        @Override
         public V getDefaultValue() {
                 return defaultValue;
         }
 
-        public ContinousHashProvider<K> getHashProvider() {
+        public ContinuousHashProvider<K> getHashProvider() {
                 return hashProvider;
         }
 
@@ -80,7 +80,9 @@ public class VersionedMapImpl<K, V> implements VersionedMap<K, V> {
                         Iterator<K> keyIterator = keys.iterator();
                         Iterator<V> valueIterator = values.iterator();
                         while (keyIterator.hasNext()) {
-                                this.put(keyIterator.next(), valueIterator.next());
+                                var key = keyIterator.next();
+                                var value = valueIterator.next();
+                                this.put(key,value);
                         }
                 } else {
                         while (cursor.move()) {
@@ -113,17 +115,16 @@ public class VersionedMapImpl<K, V> implements VersionedMap<K, V> {
         }
 
         @Override
-        public DiffCursor<K, V> getDiffCursor(long toVersion) {
-                Cursor<K, V> fromCursor = this.getAll();
-                VersionedMap<K, V> toMap = this.store.createMap(toVersion);
-                Cursor<K, V> toCursor = toMap.getAll();
-                return new MapDiffCursor<>(this.hashProvider, this.defaultValue, fromCursor, toCursor);
-
+        public DiffCursor<K, V> getDiffCursor(Version toVersion) {
+                InOrderMapCursor<K, V> fromCursor = new InOrderMapCursor<>(this);
+                VersionedMapStateImpl<K, V> toMap = (VersionedMapStateImpl<K, V>) this.store.createMap(toVersion);
+                InOrderMapCursor<K, V> toCursor = new InOrderMapCursor<>(toMap);
+                return new MapDiffCursor<>(this.defaultValue, fromCursor, toCursor);
         }
 
 
         @Override
-        public long commit() {
+        public Version commit() {
                 return this.store.commit(root, this);
         }
 
@@ -132,20 +133,21 @@ public class VersionedMapImpl<K, V> implements VersionedMap<K, V> {
         }
 
         @Override
-        public void restore(long state) {
+        public void restore(Version state) {
                 root = this.store.revert(state);
         }
 
-        public void prettyPrint() {
-                StringBuilder s = new StringBuilder();
+        public String prettyPrint() {
                 if (this.root != null) {
+                        StringBuilder s = new StringBuilder();
                         this.root.prettyPrint(s, 0, -1);
-                        System.out.println(s.toString());
+                        return s.toString();
                 } else {
-                        System.out.println("empty tree");
+                        return "empty tree";
                 }
         }
 
+        @Override
         public void checkIntegrity() {
                 if (this.root != null) {
                         this.root.checkIntegrity(hashProvider, defaultValue, 0);
@@ -155,11 +157,15 @@ public class VersionedMapImpl<K, V> implements VersionedMap<K, V> {
         @Override
         public int contentHashCode(ContentHashCode mode) {
                 // Calculating the root hashCode is always fast, because {@link Node} caches its hashCode.
-                return Objects.hashCode(root);
+                if(root == null) {
+                        return 0;
+                } else {
+                        return root.hashCode();
+                }
         }
 
         @Override
         public boolean contentEquals(AnyVersionedMap other) {
-                return other instanceof VersionedMapImpl<?, ?> otherImpl && Objects.equals(root, otherImpl.root);
+                return other instanceof VersionedMapStateImpl<?, ?> otherImpl && Objects.equals(root, otherImpl.root);
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreConfiguration.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStoreStateConfiguration.java
index b00cd961..6650f565 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreConfiguration.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStoreStateConfiguration.java
@@ -1,21 +1,25 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.store.map;
+package tools.refinery.store.map.internal.state;
 
-public class VersionedMapStoreConfiguration {
+import tools.refinery.store.map.ContinuousHashProvider;
+import tools.refinery.store.map.VersionedMapStore;
 
-        public VersionedMapStoreConfiguration() {
+public class VersionedMapStoreStateConfiguration {
+
+        public VersionedMapStoreStateConfiguration() {
 
         }
-        public VersionedMapStoreConfiguration(boolean immutableWhenCommitting, boolean sharedNodeCacheInStore,
-                        boolean sharedNodeCacheInStoreGroups) {
+        public VersionedMapStoreStateConfiguration(boolean immutableWhenCommitting, boolean sharedNodeCacheInStore,
+                                                                                           boolean sharedNodeCacheInStoreGroups, boolean versionFreeingEnabled) {
                 super();
                 this.immutableWhenCommitting = immutableWhenCommitting;
                 this.sharedNodeCacheInStore = sharedNodeCacheInStore;
                 this.sharedNodeCacheInStoreGroups = sharedNodeCacheInStoreGroups;
+                this.versionFreeingEnabled = versionFreeingEnabled;
         }
 
         /**
@@ -42,12 +46,17 @@ public class VersionedMapStoreConfiguration {
 
         /**
          * If true, all sub-nodes are cached within a group of
-         * {@link VersionedMapStoreImpl#createSharedVersionedMapStores(int, ContinousHashProvider, Object, VersionedMapStoreConfiguration)}.
-         * If {@link VersionedMapStoreConfiguration#sharedNodeCacheInStore} is
+         * {@link VersionedMapStoreStateImpl#createSharedVersionedMapStores(int, ContinuousHashProvider, Object, VersionedMapStoreStateConfiguration)}.
+         * If {@link VersionedMapStoreStateConfiguration#sharedNodeCacheInStore} is
          * <code>false</code>, then it has currently no impact.
          */
         private boolean sharedNodeCacheInStoreGroups = true;
         public boolean isSharedNodeCacheInStoreGroups() {
                 return sharedNodeCacheInStoreGroups;
         }
+
+        private boolean versionFreeingEnabled = true;
+        public boolean isVersionFreeingEnabled() {
+                return versionFreeingEnabled;
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStoreStateImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStoreStateImpl.java
new file mode 100644
index 00000000..8ff3f8e7
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStoreStateImpl.java
@@ -0,0 +1,119 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.internal.state;
+
+import tools.refinery.store.map.*;
+
+import java.util.*;
+
+public class VersionedMapStoreStateImpl<K, V> implements VersionedMapStore<K, V> {
+        // Configuration
+        private final boolean immutableWhenCommitting;
+
+        // Static data
+        protected final ContinuousHashProvider<K> hashProvider;
+        protected final V defaultValue;
+
+        protected final Map<Node<K, V>, ImmutableNode<K, V>> nodeCache;
+
+        public VersionedMapStoreStateImpl(ContinuousHashProvider<K> hashProvider, V defaultValue,
+                                                                          VersionedMapStoreStateConfiguration config) {
+                this.immutableWhenCommitting = config.isImmutableWhenCommitting();
+                this.hashProvider = hashProvider;
+                this.defaultValue = defaultValue;
+                if (config.isSharedNodeCacheInStore()) {
+                        nodeCache = createNoteCache(config);
+                } else {
+                        nodeCache = null;
+                }
+        }
+
+        private VersionedMapStoreStateImpl(ContinuousHashProvider<K> hashProvider, V defaultValue,
+                                                                           Map<Node<K, V>, ImmutableNode<K, V>> nodeCache, VersionedMapStoreStateConfiguration config) {
+                this.immutableWhenCommitting = config.isImmutableWhenCommitting();
+                this.hashProvider = hashProvider;
+                this.defaultValue = defaultValue;
+                this.nodeCache = nodeCache;
+        }
+
+        public VersionedMapStoreStateImpl(ContinuousHashProvider<K> hashProvider, V defaultValue) {
+                this(hashProvider, defaultValue, new VersionedMapStoreStateConfiguration());
+        }
+
+        public static <K, V> List<VersionedMapStore<K, V>> createSharedVersionedMapStores(int amount,
+                                                                                                                                                                          ContinuousHashProvider<K> hashProvider, V defaultValue,
+                                                                                                                                                                          VersionedMapStoreStateConfiguration config) {
+                List<VersionedMapStore<K, V>> result = new ArrayList<>(amount);
+                if (config.isSharedNodeCacheInStoreGroups()) {
+                        Map<Node<K, V>, ImmutableNode<K, V>> nodeCache;
+                        if (config.isSharedNodeCacheInStore()) {
+                                nodeCache = createNoteCache(config);
+                        } else {
+                                nodeCache = null;
+                        }
+                        for (int i = 0; i < amount; i++) {
+                                result.add(new VersionedMapStoreStateImpl<>(hashProvider, defaultValue, nodeCache, config));
+                        }
+                } else {
+                        for (int i = 0; i < amount; i++) {
+                                result.add(new VersionedMapStoreStateImpl<>(hashProvider, defaultValue, config));
+                        }
+                }
+                return result;
+        }
+
+        private static <K,V> Map<K,V> createNoteCache(VersionedMapStoreStateConfiguration config) {
+                if(config.isVersionFreeingEnabled()) {
+                        return new WeakHashMap<>();
+                } else {
+                        return new HashMap<>();
+                }
+        }
+
+        public static <K, V> List<VersionedMapStore<K, V>> createSharedVersionedMapStores(int amount,
+                                                                                                                                                                          ContinuousHashProvider<K> hashProvider, V defaultValue) {
+                return createSharedVersionedMapStores(amount, hashProvider, defaultValue, new VersionedMapStoreStateConfiguration());
+        }
+
+        @Override
+        public VersionedMap<K, V> createMap() {
+                return new VersionedMapStateImpl<>(this, hashProvider, defaultValue);
+        }
+
+        @Override
+        public VersionedMap<K, V> createMap(Version state) {
+                ImmutableNode<K, V> data = revert(state);
+                return new VersionedMapStateImpl<>(this, hashProvider, defaultValue, data);
+        }
+
+        @SuppressWarnings("unchecked")
+        public synchronized ImmutableNode<K, V> revert(Version state) {
+                return (ImmutableNode<K, V>) state;
+        }
+
+        public synchronized Version commit(Node<K, V> data, VersionedMapStateImpl<K, V> mapToUpdateRoot) {
+                ImmutableNode<K, V> immutable;
+                if (data != null) {
+                        immutable = data.toImmutable(this.nodeCache);
+                } else {
+                        immutable = null;
+                }
+
+                if (this.immutableWhenCommitting) {
+                        mapToUpdateRoot.setRoot(immutable);
+                }
+                return immutable;
+        }
+
+        @Override
+        public DiffCursor<K, V> getDiffCursor(Version fromState, Version toState) {
+                VersionedMapStateImpl<K, V> map1 = (VersionedMapStateImpl<K, V>) createMap(fromState);
+                VersionedMapStateImpl<K, V> map2 = (VersionedMapStateImpl<K, V>) createMap(toState);
+                InOrderMapCursor<K, V> cursor1 = new InOrderMapCursor<>(map1);
+                InOrderMapCursor<K, V> cursor2 = new InOrderMapCursor<>(map2);
+                return new MapDiffCursor<>(this.defaultValue, cursor1, cursor2);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java
index ea670cbc..1b15e4cf 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java
@@ -7,6 +7,7 @@ package tools.refinery.store.model;
 
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.map.DiffCursor;
+import tools.refinery.store.map.Version;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
 
@@ -24,7 +25,7 @@ public non-sealed interface Interpretation<T> extends AnyInterpretation {
 
         void putAll(Cursor<Tuple, T> cursor);
 
-        DiffCursor<Tuple, T> getDiffCursor(long to);
+        DiffCursor<Tuple, T> getDiffCursor(Version to);
 
         void addListener(InterpretationListener<T> listener, boolean alsoWhenRestoring);
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/Model.java b/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
index d58d91c3..e2ab72e7 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
@@ -6,18 +6,20 @@
 package tools.refinery.store.model;
 
 import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.map.Version;
 import tools.refinery.store.map.Versioned;
+import tools.refinery.store.model.internal.VersionedInterpretation;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
 
+import java.util.Map;
 import java.util.Optional;
 
 public interface Model extends Versioned {
-        long NO_STATE_ID = -1;
-
+        Version NO_STATE_ID = null;
         ModelStore getStore();
 
-        long getState();
+        Version getState();
 
         boolean hasUncommittedChanges();
 
@@ -27,7 +29,7 @@ public interface Model extends Versioned {
 
         <T> Interpretation<T> getInterpretation(Symbol<T> symbol);
 
-        ModelDiffCursor getDiffCursor(long to);
+        ModelDiffCursor getDiffCursor(Version to);
 
         <T extends ModelAdapter> Optional<T> tryGetAdapter(Class<? extends T> adapterType);
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelListener.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelListener.java
index a9ad8cfd..703ee10a 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/ModelListener.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelListener.java
@@ -5,6 +5,8 @@
  */
 package tools.refinery.store.model;
 
+import tools.refinery.store.map.Version;
+
 public interface ModelListener {
         default void beforeCommit() {
         }
@@ -12,7 +14,7 @@ public interface ModelListener {
         default void afterCommit() {
         }
 
-        default void beforeRestore(long state) {
+        default void beforeRestore(Version state) {
         }
 
         default void afterRestore() {
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
index b10eb8a4..89382b3a 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
@@ -6,23 +6,21 @@
 package tools.refinery.store.model;
 
 import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.store.map.Version;
 import tools.refinery.store.model.internal.ModelStoreBuilderImpl;
 import tools.refinery.store.representation.AnySymbol;
 
 import java.util.Collection;
 import java.util.Optional;
-import java.util.Set;
 
 public interface ModelStore {
         Collection<AnySymbol> getSymbols();
 
         Model createEmptyModel();
 
-        Model createModelForState(long state);
+        Model createModelForState(Version state);
 
-        Set<Long> getStates();
-
-        ModelDiffCursor getDiffCursor(long from, long to);
+        ModelDiffCursor getDiffCursor(Version from, Version to);
 
         <T extends ModelStoreAdapter> Optional<T> tryGetAdapter(Class<? extends T> adapterType);
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/TupleHashProvider.java b/subprojects/store/src/main/java/tools/refinery/store/model/TupleHashProvider.java
index fe1c2ab5..3c94541f 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/TupleHashProvider.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/TupleHashProvider.java
@@ -5,41 +5,45 @@
  */
 package tools.refinery.store.model;
 
-import tools.refinery.store.map.ContinousHashProvider;
+import tools.refinery.store.map.ContinuousHashProvider;
 import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple1;
+import tools.refinery.store.tuple.Tuple2;
 
-public class TupleHashProvider implements ContinousHashProvider<Tuple> {
-        protected static final int[] primes = new int[] { 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101,
-                        103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211,
-                        223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337,
-                        347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461,
-                        463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601,
-                        607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739,
-                        743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881,
-                        883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021,
-                        1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151,
-                        1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283,
-                        1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429,
-                        1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549,
-                        1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667,
-                        1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811,
-                        1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973,
-                        1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089,
-                        2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243,
-                        2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377,
-                        2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531,
-                        2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677,
-                        2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791,
-                        2797, 2801, 2803, 2819, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217,
-                        3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359,
-                        3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517,
-                        3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637,
-                        3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793,
-                        3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911 };
+public class TupleHashProvider implements ContinuousHashProvider<Tuple> {
+        protected static final int[] primes = new int[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
+                        61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173,
+                        179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283,
+                        293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421,
+                        431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563,
+                        569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683,
+                        691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829,
+                        839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983,
+                        991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097,
+                        1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231,
+                        1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373,
+                        1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493,
+                        1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619,
+                        1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759,
+                        1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907,
+                        1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053,
+                        2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203,
+                        2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339,
+                        2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459,
+                        2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633,
+                        2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741,
+                        2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169,
+                        3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319,
+                        3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463,
+                        3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593,
+                        3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733,
+                        3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889,
+                        3907, 3911 };
 
-        public static final long LARGEST_PRIME_30_BITS = 1073741789;
-
-        public static final int MAX_MODEL_SIZE = (int) LARGEST_PRIME_30_BITS;
+        protected static final long LARGEST_PRIME_30_BITS_LONG = 1073741789;
+        protected static final int LARGEST_PRIME_30_BITS_INTEGER = 1073741789;
+        protected static final int LARGEST_BINARY_INDEX_1 = LARGEST_PRIME_30_BITS_INTEGER / 4;
+        public static final int MAX_MODEL_SIZE = LARGEST_PRIME_30_BITS_INTEGER;
 
         public static final TupleHashProvider INSTANCE = new TupleHashProvider();
 
@@ -52,15 +56,68 @@ public class TupleHashProvider implements ContinousHashProvider<Tuple> {
 
         @Override
         public int getHash(Tuple key, int index) {
-                if (index >= primes.length) {
-                        throw new IllegalArgumentException("Not enough prime numbers to support index");
+                if(key instanceof Tuple1 t1) {
+                        return t1.value0();
+                } else if(key instanceof Tuple2 t2){
+                        if(index == 0) {
+                                return murmur3T2(t2.value0(), t2.value1());
+                        } else if(index == 1) {
+                                return lagrangeT2I0Quick(t2);
+                        } else if(index == 2) {
+                                return lagrangeT2I1Quick(t2);
+                        } else {
+                                return lagrangeTXIX(key, index-1);
+                        }
+                } else {
+                        return lagrangeTXIX(key, index);
                 }
+
+        }
+
+        private static int lagrangeT2I0Quick(Tuple2 t2) {
+                int result = 2 * t2.value0() + t2.value1();
+                if (result > LARGEST_PRIME_30_BITS_INTEGER) {
+                        return result % LARGEST_PRIME_30_BITS_INTEGER;
+                } else
+                        return result;
+        }
+        private static int lagrangeT2I1Quick(Tuple2 t2) {
+                int value0 = t2.value0();
+                int value1 = t2.value1();
+                if(value0 < LARGEST_BINARY_INDEX_1 && value1 < LARGEST_BINARY_INDEX_1) {
+                        return 3* value0 + value1;
+                } else {
+                        return lagrangeTXIX(t2, 1);
+                }
+        }
+
+        private static int lagrangeTXIX(Tuple key, int index) {
                 long accumulator = 0;
                 final int prime = primes[index];
                 for (int i = 0; i < key.getSize(); i++) {
-                        accumulator = (prime * accumulator + key.get(i)) % MAX_MODEL_SIZE;
+                        accumulator = (prime * accumulator + key.get(i)) % LARGEST_PRIME_30_BITS_LONG;
                 }
 
                 return (int) accumulator;
         }
+
+        private static int murmur3T2(int v0, int v1)
+        {
+                int h = 0;
+
+                h = murmur32Scramble(v0, h);
+                h = murmur32Scramble(v1, h);
+
+                return h;
+        }
+
+        private static int murmur32Scramble(int k, int h) {
+                k *= 0xcc9e2d51;
+                k = (k << 15) | (k >>> 17);
+                k *= 0x1b873593;
+                h ^= k;
+                h = (h << 13) | (h >>> 19);
+                h = h * 5 + 0xe6546b64;
+                return h;
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/TupleHashProviderBitMagic.java b/subprojects/store/src/main/java/tools/refinery/store/model/TupleHashProviderBitMagic.java
deleted file mode 100644
index 14116a90..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/model/TupleHashProviderBitMagic.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.model;
-
-import tools.refinery.store.map.ContinousHashProvider;
-import tools.refinery.store.tuple.Tuple;
-
-public class TupleHashProviderBitMagic implements ContinousHashProvider<Tuple> {
-
-        @Override
-        public int getHash(Tuple key, int index) {
-                if(key.getSize() == 1) {
-                        return key.get(0);
-                }
-
-                int result = 0;
-                final int startBitIndex = index*30;
-                final int finalBitIndex = startBitIndex+30;
-                final int arity = key.getSize();
-
-                for(int i = startBitIndex; i<=finalBitIndex; i++) {
-                        final int selectedKey = key.get(i%arity);
-                        final int selectedPosition = 1<<(i/arity);
-                        if((selectedKey&selectedPosition) != 0) {
-                                result |= 1<<(i%30);
-                        }
-                }
-
-                return result;
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/IndexedVersionedInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/IndexedVersionedInterpretation.java
index e0a371de..0be16f77 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/IndexedVersionedInterpretation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/IndexedVersionedInterpretation.java
@@ -7,7 +7,6 @@ package tools.refinery.store.model.internal;
 
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.map.VersionedMap;
-import tools.refinery.store.map.VersionedMapStore;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
 
@@ -16,9 +15,8 @@ import java.util.Objects;
 class IndexedVersionedInterpretation<T> extends VersionedInterpretation<T> {
         private final BaseIndexer<T> indexer;
 
-        public IndexedVersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMapStore<Tuple, T> store,
-                                                                                  VersionedMap<Tuple, T> map) {
-                super(model, symbol, store, map);
+        public IndexedVersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMap<Tuple, T> map) {
+                super(model, symbol, map);
                 indexer = new BaseIndexer<>(symbol.arity(), map);
         }
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
index c5475a1a..2b12d5a6 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
@@ -8,6 +8,7 @@ package tools.refinery.store.model.internal;
 import tools.refinery.store.adapter.AdapterUtils;
 import tools.refinery.store.adapter.ModelAdapter;
 import tools.refinery.store.map.DiffCursor;
+import tools.refinery.store.map.Version;
 import tools.refinery.store.model.*;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
@@ -17,21 +18,21 @@ import java.util.*;
 
 public class ModelImpl implements Model {
         private final ModelStore store;
-        private long state;
-        private Map<? extends AnySymbol, ? extends VersionedInterpretation<?>> interpretations;
+        private Version state;
+        private LinkedHashMap<? extends AnySymbol, ? extends VersionedInterpretation<?>> interpretations;
         private final List<ModelAdapter> adapters;
         private final List<ModelListener> listeners = new ArrayList<>();
         private boolean uncommittedChanges;
         private ModelAction pendingAction = ModelAction.NONE;
-        private long restoringToState = NO_STATE_ID;
+        private Version restoringToState = null;
 
-        ModelImpl(ModelStore store, long state, int adapterCount) {
+        ModelImpl(ModelStore store, Version state, int adapterCount) {
                 this.store = store;
                 this.state = state;
                 adapters = new ArrayList<>(adapterCount);
         }
 
-        void setInterpretations(Map<? extends AnySymbol, ? extends VersionedInterpretation<?>> interpretations) {
+        void setInterpretations(LinkedHashMap<? extends AnySymbol, ? extends VersionedInterpretation<?>> interpretations) {
                 this.interpretations = interpretations;
         }
 
@@ -41,7 +42,7 @@ public class ModelImpl implements Model {
         }
 
         @Override
-        public long getState() {
+        public Version getState() {
                 return state;
         }
 
@@ -57,7 +58,7 @@ public class ModelImpl implements Model {
         }
 
         @Override
-        public ModelDiffCursor getDiffCursor(long to) {
+        public ModelDiffCursor getDiffCursor(Version to) {
                 var diffCursors = new HashMap<AnySymbol, DiffCursor<Tuple, ?>>(interpretations.size());
                 for (var entry : interpretations.entrySet()) {
                         diffCursors.put(entry.getKey(), entry.getValue().getDiffCursor(to));
@@ -65,7 +66,7 @@ public class ModelImpl implements Model {
                 return new ModelDiffCursor(diffCursors);
         }
 
-        private void setState(long state) {
+        private void setState(Version state) {
                 this.state = state;
                 uncommittedChanges = false;
         }
@@ -82,11 +83,11 @@ public class ModelImpl implements Model {
         }
 
         private boolean hasPendingAction() {
-                return pendingAction != ModelAction.NONE || restoringToState != NO_STATE_ID;
+                return pendingAction != ModelAction.NONE || restoringToState != null;
         }
 
         @Override
-        public long commit() {
+        public Version commit() {
                 if (hasPendingAction()) {
                         throw pendingActionError("commit");
                 }
@@ -94,43 +95,40 @@ public class ModelImpl implements Model {
                 try {
                         int listenerCount = listeners.size();
                         int i = listenerCount;
-                        long version = 0;
+
+                        // Before commit message to listeners
                         while (i > 0) {
                                 i--;
                                 listeners.get(i).beforeCommit();
                         }
-                        boolean versionSet = false;
-                        for (var interpretation : interpretations.values()) {
-                                long newVersion = interpretation.commit();
-                                if (versionSet) {
-                                        if (version != newVersion) {
-                                                throw new IllegalStateException("Interpretations in model have different versions (%d and %d)"
-                                                                .formatted(version, newVersion));
-                                        }
-                                } else {
-                                        version = newVersion;
-                                        versionSet = true;
-                                }
+
+                        // Doing the commit on the interpretations
+                        Version[] interpretationVersions = new Version[interpretations.size()];
+                        int j = 0;
+                        for (var interpretationEntry : interpretations.entrySet()) {
+                                interpretationVersions[j++] = interpretationEntry.getValue().commit();
                         }
-                        setState(version);
+                        ModelVersion modelVersion = new ModelVersion(interpretationVersions);
+                        setState(modelVersion);
+
+                        // After commit message to listeners
                         while (i < listenerCount) {
                                 listeners.get(i).afterCommit();
                                 i++;
                         }
-                        return version;
+
+                        return modelVersion;
                 } finally {
                         pendingAction = ModelAction.NONE;
                 }
         }
 
         @Override
-        public void restore(long version) {
+        public void restore(Version version) {
                 if (hasPendingAction()) {
-                        throw pendingActionError("restore to %d".formatted(version));
-                }
-                if (!store.getStates().contains(version)) {
-                        throw new IllegalArgumentException("Store does not contain state %d".formatted(version));
+                        throw pendingActionError("restore to %s".formatted(version));
                 }
+
                 pendingAction = ModelAction.RESTORE;
                 restoringToState = version;
                 try {
@@ -140,9 +138,11 @@ public class ModelImpl implements Model {
                                 i--;
                                 listeners.get(i).beforeRestore(version);
                         }
+                        int j = 0;
                         for (var interpretation : interpretations.values()) {
-                                interpretation.restore(version);
+                                interpretation.restore(ModelVersion.getInternalVersion(version, j++));
                         }
+
                         setState(version);
                         while (i < listenerCount) {
                                 listeners.get(i).afterRestore();
@@ -150,7 +150,7 @@ public class ModelImpl implements Model {
                         }
                 } finally {
                         pendingAction = ModelAction.NONE;
-                        restoringToState = NO_STATE_ID;
+                        restoringToState = null;
                 }
         }
 
@@ -159,7 +159,7 @@ public class ModelImpl implements Model {
                         case NONE -> throw new IllegalArgumentException("Trying to throw pending action error when there is no " +
                                         "pending action");
                         case COMMIT -> "commit";
-                        case RESTORE -> "restore to %d".formatted(restoringToState);
+                        case RESTORE -> "restore to %s".formatted(restoringToState);
                 };
                 return new IllegalStateException("Cannot %s due to pending %s".formatted(currentActionName, pendingActionName));
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java
index 5c688178..2dde7a4c 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java
@@ -8,11 +8,11 @@ package tools.refinery.store.model.internal;
 import tools.refinery.store.adapter.AdapterUtils;
 import tools.refinery.store.adapter.ModelAdapterBuilder;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
+import tools.refinery.store.map.VersionedMapStoreFactory;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.model.ModelStoreConfiguration;
-import tools.refinery.store.model.TupleHashProvider;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
@@ -20,8 +20,8 @@ import tools.refinery.store.tuple.Tuple;
 import java.util.*;
 
 public class ModelStoreBuilderImpl implements ModelStoreBuilder {
-        private final Set<AnySymbol> allSymbols = new HashSet<>();
-        private final Map<SymbolEquivalenceClass<?>, List<AnySymbol>> equivalenceClasses = new HashMap<>();
+        private final LinkedHashSet<AnySymbol> allSymbols = new LinkedHashSet<>();
+        private final LinkedHashMap<SymbolEquivalenceClass<?>, List<AnySymbol>> equivalenceClasses = new LinkedHashMap<>();
         private final List<ModelAdapterBuilder> adapters = new ArrayList<>();
 
         @Override
@@ -71,7 +71,7 @@ public class ModelStoreBuilderImpl implements ModelStoreBuilder {
                 for (int i = adapters.size() - 1; i >= 0; i--) {
                         adapters.get(i).configure(this);
                 }
-                var stores = new HashMap<AnySymbol, VersionedMapStore<Tuple, ?>>(allSymbols.size());
+                var stores = new LinkedHashMap<AnySymbol, VersionedMapStore<Tuple, ?>>(allSymbols.size());
                 for (var entry : equivalenceClasses.entrySet()) {
                         createStores(stores, entry.getKey(), entry.getValue());
                 }
@@ -86,8 +86,12 @@ public class ModelStoreBuilderImpl implements ModelStoreBuilder {
         private <T> void createStores(Map<AnySymbol, VersionedMapStore<Tuple, ?>> stores,
                                                                   SymbolEquivalenceClass<T> equivalenceClass, List<AnySymbol> symbols) {
                 int size = symbols.size();
-                var storeGroup = VersionedMapStoreImpl.createSharedVersionedMapStores(size, TupleHashProvider.INSTANCE,
-                                equivalenceClass.defaultValue());
+                VersionedMapStoreFactory<Tuple,T> mapFactory = VersionedMapStore
+                                .<Tuple,T>builder()
+                                .strategy(VersionedMapStoreFactoryBuilder.StoreStrategy.DELTA)
+                                .defaultValue(equivalenceClass.defaultValue())
+                                .build();
+                var storeGroup = mapFactory.createGroup(size);
                 for (int i = 0; i < size; i++) {
                         stores.put(symbols.get(i), storeGroup.get(i));
                 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
index 60b735e6..a320a618 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
@@ -8,8 +8,8 @@ package tools.refinery.store.model.internal;
 import tools.refinery.store.adapter.AdapterUtils;
 import tools.refinery.store.adapter.ModelStoreAdapter;
 import tools.refinery.store.map.DiffCursor;
+import tools.refinery.store.map.Version;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelDiffCursor;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.representation.AnySymbol;
@@ -18,10 +18,10 @@ import tools.refinery.store.tuple.Tuple;
 import java.util.*;
 
 public class ModelStoreImpl implements ModelStore {
-        private final Map<? extends AnySymbol, ? extends VersionedMapStore<Tuple, ?>> stores;
+        private final LinkedHashMap<? extends AnySymbol, ? extends VersionedMapStore<Tuple, ?>> stores;
         private final List<ModelStoreAdapter> adapters;
 
-        ModelStoreImpl(Map<? extends AnySymbol, ? extends VersionedMapStore<Tuple, ?>> stores, int adapterCount) {
+        ModelStoreImpl(LinkedHashMap<? extends AnySymbol, ? extends VersionedMapStore<Tuple, ?>> stores, int adapterCount) {
                 this.stores = stores;
                 adapters = new ArrayList<>(adapterCount);
         }
@@ -31,14 +31,14 @@ public class ModelStoreImpl implements ModelStore {
                 return Collections.unmodifiableCollection(stores.keySet());
         }
 
-        private ModelImpl createModelWithoutInterpretations(long state) {
+        private ModelImpl createModelWithoutInterpretations(Version state) {
                 return new ModelImpl(this, state, adapters.size());
         }
 
         @Override
         public ModelImpl createEmptyModel() {
-                var model = createModelWithoutInterpretations(Model.NO_STATE_ID);
-                var interpretations = new HashMap<AnySymbol, VersionedInterpretation<?>>(stores.size());
+                var model = createModelWithoutInterpretations(null);
+                var interpretations = new LinkedHashMap<AnySymbol, VersionedInterpretation<?>>(stores.size());
                 for (var entry : this.stores.entrySet()) {
                         var symbol = entry.getKey();
                         interpretations.put(symbol, VersionedInterpretation.of(model, symbol, entry.getValue()));
@@ -49,13 +49,21 @@ public class ModelStoreImpl implements ModelStore {
         }
 
         @Override
-        public synchronized ModelImpl createModelForState(long state) {
+        public synchronized ModelImpl createModelForState(Version state) {
                 var model = createModelWithoutInterpretations(state);
-                var interpretations = new HashMap<AnySymbol, VersionedInterpretation<?>>(stores.size());
+                var interpretations = new LinkedHashMap<AnySymbol, VersionedInterpretation<?>>(stores.size());
+
+                int i=0;
                 for (var entry : this.stores.entrySet()) {
                         var symbol = entry.getKey();
-                        interpretations.put(symbol, VersionedInterpretation.of(model, symbol, entry.getValue(), state));
+                        interpretations.put(symbol,
+                                        VersionedInterpretation.of(
+                                                        model,
+                                                        symbol,
+                                                        entry.getValue(),
+                                                        ModelVersion.getInternalVersion(state,i++)));
                 }
+
                 model.setInterpretations(interpretations);
                 adaptModel(model);
                 return model;
@@ -69,16 +77,7 @@ public class ModelStoreImpl implements ModelStore {
         }
 
         @Override
-        public synchronized Set<Long> getStates() {
-                var iterator = stores.values().iterator();
-                if (iterator.hasNext()) {
-                        return Set.copyOf(iterator.next().getStates());
-                }
-                return Set.of(0L);
-        }
-
-        @Override
-        public synchronized ModelDiffCursor getDiffCursor(long from, long to) {
+        public synchronized ModelDiffCursor getDiffCursor(Version from, Version to) {
                 var diffCursors = new HashMap<AnySymbol, DiffCursor<?, ?>>();
                 for (var entry : stores.entrySet()) {
                         var representation = entry.getKey();
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelVersion.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelVersion.java
new file mode 100644
index 00000000..c3e52084
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelVersion.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.model.internal;
+
+import tools.refinery.store.map.Version;
+
+import java.util.Arrays;
+
+public class ModelVersion implements Version {
+        final Version[] mapVersions;
+
+        public ModelVersion(Version[] mapVersions) {
+                this.mapVersions = mapVersions;
+        }
+
+        public static Version getInternalVersion(Version modelVersion, int interpretationIndex) {
+                return ((ModelVersion) modelVersion).mapVersions[interpretationIndex];
+        }
+
+        @Override
+        public String toString() {
+                return "ModelVersion{" +
+                                "mapVersions=" + Arrays.toString(mapVersions) +
+                                '}';
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/NullaryVersionedInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/NullaryVersionedInterpretation.java
index 96639a8e..4a8e6752 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/NullaryVersionedInterpretation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/NullaryVersionedInterpretation.java
@@ -7,14 +7,12 @@ package tools.refinery.store.model.internal;
 
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.map.VersionedMap;
-import tools.refinery.store.map.VersionedMapStore;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
 
 class NullaryVersionedInterpretation<T> extends VersionedInterpretation<T> {
-        public NullaryVersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMapStore<Tuple, T> store,
-                                                                                  VersionedMap<Tuple, T> map) {
-                super(model, symbol, store, map);
+        public NullaryVersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMap<Tuple, T> map) {
+                super(model, symbol, map);
         }
 
         @Override
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/UnaryVersionedInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/UnaryVersionedInterpretation.java
index 4ec04358..75946680 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/UnaryVersionedInterpretation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/UnaryVersionedInterpretation.java
@@ -8,16 +8,14 @@ package tools.refinery.store.model.internal;
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.map.Cursors;
 import tools.refinery.store.map.VersionedMap;
-import tools.refinery.store.map.VersionedMapStore;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
 
 import java.util.Objects;
 
 class UnaryVersionedInterpretation<T> extends VersionedInterpretation<T> {
-        public UnaryVersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMapStore<Tuple, T> store,
-                                                                                VersionedMap<Tuple, T> map) {
-                super(model, symbol, store, map);
+        public UnaryVersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMap<Tuple, T> map) {
+                super(model, symbol, map);
         }
 
         private void validateSlot(int slot) {
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
index 877028cc..71df3962 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
@@ -5,15 +5,10 @@
  */
 package tools.refinery.store.model.internal;
 
-import tools.refinery.store.map.Cursor;
-import tools.refinery.store.map.DiffCursor;
-import tools.refinery.store.map.VersionedMap;
-import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.internal.MapDiffCursor;
+import tools.refinery.store.map.*;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.model.InterpretationListener;
 import tools.refinery.store.model.Model;
-import tools.refinery.store.model.TupleHashProvider;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
@@ -24,16 +19,13 @@ import java.util.List;
 public abstract class VersionedInterpretation<T> implements Interpretation<T> {
         private final ModelImpl model;
         private final Symbol<T> symbol;
-        private final VersionedMapStore<Tuple, T> store;
         private final VersionedMap<Tuple, T> map;
         private final List<InterpretationListener<T>> listeners = new ArrayList<>();
         private final List<InterpretationListener<T>> restoreListeners = new ArrayList<>();
 
-        protected VersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMapStore<Tuple, T> store,
-                                                                          VersionedMap<Tuple, T> map) {
+        protected VersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMap<Tuple, T> map) {
                 this.model = model;
                 this.symbol = symbol;
-                this.store = store;
                 this.map = map;
         }
 
@@ -116,13 +108,11 @@ public abstract class VersionedInterpretation<T> implements Interpretation<T> {
         }
 
         @Override
-        public DiffCursor<Tuple, T> getDiffCursor(long to) {
-                var fromCursor = getAll();
-                var toCursor = store.createMap(to).getAll();
-                return new MapDiffCursor<>(TupleHashProvider.INSTANCE, symbol.defaultValue(), fromCursor, toCursor);
+        public DiffCursor<Tuple, T> getDiffCursor(Version to) {
+                return map.getDiffCursor(to);
         }
 
-        public long commit() {
+        Version commit() {
                 return map.commit();
         }
 
@@ -130,7 +120,7 @@ public abstract class VersionedInterpretation<T> implements Interpretation<T> {
                 return !restoreListeners.isEmpty();
         }
 
-        public void restore(long state) {
+        public void restore(Version state) {
                 if (shouldNotifyRestoreListeners()) {
                         var diffCursor = getDiffCursor(state);
                         while (diffCursor.move()) {
@@ -158,23 +148,23 @@ public abstract class VersionedInterpretation<T> implements Interpretation<T> {
                 @SuppressWarnings("unchecked")
                 var typedSymbol = (Symbol<T>) symbol;
                 var map = store.createMap();
-                return of(model, typedSymbol, store, map);
+                return of(model, typedSymbol, map);
         }
 
         static <T> VersionedInterpretation<T> of(ModelImpl model, AnySymbol symbol, VersionedMapStore<Tuple, T> store,
-                                                                                         long state) {
+                                                                                         Version state) {
                 @SuppressWarnings("unchecked")
                 var typedSymbol = (Symbol<T>) symbol;
                 var map = store.createMap(state);
-                return of(model, typedSymbol, store, map);
+                return of(model, typedSymbol, map);
         }
 
         private static <T> VersionedInterpretation<T> of(ModelImpl model, Symbol<T> typedSymbol,
-                                                                                                         VersionedMapStore<Tuple, T> store, VersionedMap<Tuple, T> map) {
+                                                                                                         VersionedMap<Tuple, T> map) {
                 return switch (typedSymbol.arity()) {
-                        case 0 -> new NullaryVersionedInterpretation<>(model, typedSymbol, store, map);
-                        case 1 -> new UnaryVersionedInterpretation<>(model, typedSymbol, store, map);
-                        default -> new IndexedVersionedInterpretation<>(model, typedSymbol, store, map);
+                        case 0 -> new NullaryVersionedInterpretation<>(model, typedSymbol, map);
+                        case 1 -> new UnaryVersionedInterpretation<>(model, typedSymbol, map);
+                        default -> new IndexedVersionedInterpretation<>(model, typedSymbol, map);
                 };
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/Morphism.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/Morphism.java
new file mode 100644
index 00000000..d4ac3b58
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/Morphism.java
@@ -0,0 +1,11 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+public interface Morphism {
+        int get(int object);
+        int getSize();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/ObjectCode.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/ObjectCode.java
new file mode 100644
index 00000000..840253ea
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/ObjectCode.java
@@ -0,0 +1,11 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+public interface ObjectCode {
+        long get(int object);
+        int getSize();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCodeCalculator.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCodeCalculator.java
new file mode 100644
index 00000000..b7f1d81a
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCodeCalculator.java
@@ -0,0 +1,10 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+public interface StateCodeCalculator {
+        StateCoderResult calculateCodes();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCodeCalculatorFactory.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCodeCalculatorFactory.java
new file mode 100644
index 00000000..04e17a13
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCodeCalculatorFactory.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+import org.eclipse.collections.api.set.primitive.IntSet;
+import tools.refinery.store.model.Interpretation;
+
+import java.util.List;
+
+public interface StateCodeCalculatorFactory {
+        StateCodeCalculator create(List<? extends Interpretation<?>> interpretations, IntSet individuals);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderAdapter.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderAdapter.java
new file mode 100644
index 00000000..cb73d27e
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderAdapter.java
@@ -0,0 +1,23 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.statecoding.internal.StateCoderBuilderImpl;
+
+public interface StateCoderAdapter extends ModelAdapter {
+        StateCoderResult calculateStateCode();
+        default int calculateModelCode() {
+                return calculateStateCode().modelCode();
+        }
+        default ObjectCode calculateObjectCode() {
+                return calculateStateCode().objectCode();
+        }
+
+        static StateCoderBuilder builder() {
+                return new StateCoderBuilderImpl();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderBuilder.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderBuilder.java
new file mode 100644
index 00000000..54650825
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderBuilder.java
@@ -0,0 +1,45 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+import tools.refinery.store.adapter.ModelAdapterBuilder;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.tuple.Tuple1;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+public interface StateCoderBuilder extends ModelAdapterBuilder {
+        StateCoderBuilder exclude(AnySymbol symbol);
+        default StateCoderBuilder excludeAll(Collection<? extends AnySymbol> symbols) {
+                for(var symbol : symbols) {
+                        exclude(symbol);
+                }
+                return this;
+        }
+        default StateCoderBuilder excludeAll(AnySymbol... symbols) {
+                return excludeAll(List.of(symbols));
+        }
+
+        StateCoderBuilder individual(Tuple1 tuple);
+        default StateCoderBuilder individual(Collection<Tuple1> tuple1s) {
+                for(Tuple1 tuple : tuple1s){
+                        individual(tuple);
+                }
+                return this;
+        }
+        default StateCoderBuilder individuals(Tuple1... tuple1s) {
+                return individual(Arrays.stream(tuple1s).toList());
+        }
+
+        StateCoderBuilder stateCodeCalculatorFactory(StateCodeCalculatorFactory codeCalculatorFactory);
+        StateCoderBuilder stateEquivalenceChecker(StateEquivalenceChecker stateEquivalenceChecker);
+
+        @Override
+        StateCoderStoreAdapter build(ModelStore store);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderResult.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderResult.java
new file mode 100644
index 00000000..d2aff836
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderResult.java
@@ -0,0 +1,9 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+public record StateCoderResult(int modelCode, ObjectCode objectCode) {
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderStoreAdapter.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderStoreAdapter.java
new file mode 100644
index 00000000..c6509521
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderStoreAdapter.java
@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.store.map.Version;
+import tools.refinery.store.model.Model;
+
+public interface StateCoderStoreAdapter extends ModelStoreAdapter {
+        StateEquivalenceChecker.EquivalenceResult checkEquivalence(Version v1, Version v2);
+
+        @Override
+        StateCoderAdapter createModelAdapter(Model model);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateEquivalenceChecker.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateEquivalenceChecker.java
new file mode 100644
index 00000000..0f0023ed
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateEquivalenceChecker.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+import org.eclipse.collections.api.set.primitive.IntSet;
+import tools.refinery.store.model.AnyInterpretation;
+
+import java.util.List;
+
+public interface StateEquivalenceChecker {
+        enum EquivalenceResult {
+                ISOMORPHIC, UNKNOWN, DIFFERENT
+        }
+
+        EquivalenceResult constructMorphism(
+                        IntSet individuals, List<? extends AnyInterpretation> interpretations1, ObjectCode code1,
+                        List<? extends AnyInterpretation> interpretations2, ObjectCode code2);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderAdapterImpl.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderAdapterImpl.java
new file mode 100644
index 00000000..a2471916
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderAdapterImpl.java
@@ -0,0 +1,39 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.internal;
+
+import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.statecoding.StateCodeCalculator;
+import tools.refinery.store.statecoding.StateCoderAdapter;
+import tools.refinery.store.statecoding.StateCoderResult;
+
+public class StateCoderAdapterImpl implements StateCoderAdapter {
+        final ModelStoreAdapter storeAdapter;
+        final Model model;
+        final StateCodeCalculator calculator;
+
+        StateCoderAdapterImpl(ModelStoreAdapter storeAdapter, StateCodeCalculator calculator,  Model model) {
+                this.storeAdapter = storeAdapter;
+                this.model = model;
+                this.calculator = calculator;
+        }
+
+        @Override
+        public Model getModel() {
+                return model;
+        }
+
+        @Override
+        public ModelStoreAdapter getStoreAdapter() {
+                return storeAdapter;
+        }
+
+        @Override
+        public StateCoderResult calculateStateCode() {
+                return calculator.calculateCodes();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderBuilderImpl.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderBuilderImpl.java
new file mode 100644
index 00000000..eed591e7
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderBuilderImpl.java
@@ -0,0 +1,71 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.internal;
+
+import org.eclipse.collections.api.factory.primitive.IntSets;
+import org.eclipse.collections.api.set.primitive.MutableIntSet;
+import tools.refinery.store.adapter.AbstractModelAdapterBuilder;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.statecoding.StateCodeCalculatorFactory;
+import tools.refinery.store.statecoding.StateCoderBuilder;
+import tools.refinery.store.statecoding.StateCoderStoreAdapter;
+import tools.refinery.store.statecoding.StateEquivalenceChecker;
+import tools.refinery.store.statecoding.neighbourhood.NeighbourhoodCalculator;
+import tools.refinery.store.statecoding.stateequivalence.StateEquivalenceCheckerImpl;
+import tools.refinery.store.tuple.Tuple1;
+
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+public class StateCoderBuilderImpl extends AbstractModelAdapterBuilder<StateCoderStoreAdapter>
+                implements StateCoderBuilder {
+        private final Set<AnySymbol> excluded = new HashSet<>();
+        private final MutableIntSet individuals = IntSets.mutable.empty();
+        private StateCodeCalculatorFactory calculator = NeighbourhoodCalculator::new;
+        private StateEquivalenceChecker checker = new StateEquivalenceCheckerImpl();
+
+        @Override
+        public StateCoderBuilder exclude(AnySymbol symbol) {
+                checkNotConfigured();
+                excluded.add(symbol);
+                return this;
+        }
+
+        @Override
+        public StateCoderBuilder individual(Tuple1 tuple) {
+                checkNotConfigured();
+                individuals.add(tuple.get(0));
+                return this;
+        }
+
+        @Override
+        public StateCoderBuilder stateEquivalenceChecker(StateEquivalenceChecker stateEquivalenceChecker) {
+                checkNotConfigured();
+                this.checker = stateEquivalenceChecker;
+                return this;
+        }
+
+        @Override
+        public StateCoderBuilder stateCodeCalculatorFactory(StateCodeCalculatorFactory codeCalculatorFactory) {
+                checkNotConfigured();
+                this.calculator = codeCalculatorFactory;
+                return this;
+        }
+
+        @Override
+        protected StateCoderStoreAdapter doBuild(ModelStore store) {
+                Set<Symbol<?>> symbols = new LinkedHashSet<>();
+                for (AnySymbol symbol : store.getSymbols()) {
+                        if (!excluded.contains(symbol) && (symbol instanceof Symbol<?> typed)) {
+                                symbols.add(typed);
+                        }
+                }
+                return new StateCoderStoreAdapterImpl(store, calculator, checker, symbols, individuals);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderStoreAdapterImpl.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderStoreAdapterImpl.java
new file mode 100644
index 00000000..89586bfb
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderStoreAdapterImpl.java
@@ -0,0 +1,74 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.internal;
+
+import org.eclipse.collections.api.set.primitive.IntSet;
+import tools.refinery.store.map.Version;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.statecoding.StateCodeCalculatorFactory;
+import tools.refinery.store.statecoding.StateCoderAdapter;
+import tools.refinery.store.statecoding.StateCoderStoreAdapter;
+import tools.refinery.store.statecoding.StateEquivalenceChecker;
+
+import java.util.Collection;
+import java.util.Objects;
+
+public class StateCoderStoreAdapterImpl implements StateCoderStoreAdapter {
+        final ModelStore store;
+        final Collection<Symbol<?>> symbols;
+        final IntSet individuals;
+
+        final StateEquivalenceChecker equivalenceChecker;
+        final StateCodeCalculatorFactory codeCalculatorFactory;
+
+        StateCoderStoreAdapterImpl(ModelStore store,
+                                                           StateCodeCalculatorFactory codeCalculatorFactory,
+                                                           StateEquivalenceChecker equivalenceChecker,
+                                                           Collection<Symbol<?>> symbols,
+                                                           IntSet individuals)
+        {
+                this.codeCalculatorFactory = codeCalculatorFactory;
+                this.equivalenceChecker = equivalenceChecker;
+                this.store = store;
+                this.symbols = symbols;
+                this.individuals = individuals;
+        }
+
+        @Override
+        public ModelStore getStore() {
+                return store;
+        }
+
+        @Override
+        public StateEquivalenceChecker.EquivalenceResult checkEquivalence(Version v1, Version v2) {
+                if (Objects.equals(v1, v2)) {
+                        return StateEquivalenceChecker.EquivalenceResult.ISOMORPHIC;
+                }
+                var model1 = this.getStore().createModelForState(v1);
+                var model2 = this.getStore().createModelForState(v2);
+
+                var s1 = model1.getAdapter(StateCoderAdapter.class).calculateStateCode();
+                var s2 = model2.getAdapter(StateCoderAdapter.class).calculateStateCode();
+
+                if (s1.modelCode() != s2.modelCode()) {
+                        return StateEquivalenceChecker.EquivalenceResult.DIFFERENT;
+                }
+
+                var i1 = symbols.stream().map(model1::getInterpretation).toList();
+                var i2 = symbols.stream().map(model2::getInterpretation).toList();
+
+                return equivalenceChecker.constructMorphism(individuals, i1, s1.objectCode(), i2, s2.objectCode());
+        }
+
+        @Override
+        public StateCoderAdapter createModelAdapter(Model model) {
+                var interpretations = symbols.stream().map(model::getInterpretation).toList();
+                var coder = codeCalculatorFactory.create(interpretations, individuals);
+                return new StateCoderAdapterImpl(this, coder, model);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/AbstractNeighbourhoodCalculator.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/AbstractNeighbourhoodCalculator.java
new file mode 100644
index 00000000..5d390da2
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/AbstractNeighbourhoodCalculator.java
@@ -0,0 +1,96 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.neighbourhood;
+
+import org.eclipse.collections.api.factory.primitive.IntLongMaps;
+import org.eclipse.collections.api.map.primitive.MutableIntLongMap;
+import org.eclipse.collections.api.set.primitive.IntSet;
+import tools.refinery.store.model.AnyInterpretation;
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.statecoding.ObjectCode;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple0;
+
+import java.util.*;
+
+public abstract class AbstractNeighbourhoodCalculator {
+        protected final List<AnyInterpretation> nullImpactValues;
+        protected final LinkedHashMap<AnyInterpretation, long[]> impactValues;
+        protected final MutableIntLongMap individualHashValues = IntLongMaps.mutable.empty();
+
+        protected static final long PRIME = 31;
+
+        protected AbstractNeighbourhoodCalculator(List<? extends AnyInterpretation> interpretations, IntSet individuals) {
+                this.nullImpactValues = new ArrayList<>();
+                this.impactValues = new LinkedHashMap<>();
+                // Random isn't used for cryptographical purposes but just to assign distinguishable identifiers to symbols.
+                @SuppressWarnings("squid:S2245")
+                Random random = new Random(1);
+
+                var individualsInOrder = individuals.toSortedList(Integer::compare);
+                for(int i = 0; i<individualsInOrder.size(); i++) {
+                        individualHashValues.put(individualsInOrder.get(i), random.nextLong());
+                }
+
+                for (AnyInterpretation interpretation : interpretations) {
+                        int arity = interpretation.getSymbol().arity();
+                        if (arity == 0) {
+                                nullImpactValues.add(interpretation);
+                        } else {
+                                long[] impact = new long[arity];
+                                for (int i = 0; i < arity; i++) {
+                                        impact[i] = random.nextInt();
+                                }
+                                impactValues.put(interpretation, impact);
+                        }
+                }
+        }
+
+        protected void initializeWithIndividuals(ObjectCodeImpl previous) {
+                for (var entry : individualHashValues.keyValuesView()) {
+                        previous.set(entry.getOne(), entry.getTwo());
+                }
+        }
+
+        protected long getTupleHash1(Tuple tuple, Object value, ObjectCode objectCodeImpl) {
+                long result = Objects.hashCode(value);
+                result = result * PRIME + objectCodeImpl.get(tuple.get(0));
+                return result;
+        }
+
+        protected long getTupleHash2(Tuple tuple, Object value, ObjectCode objectCodeImpl) {
+                long result = Objects.hashCode(value);
+                result = result * PRIME + objectCodeImpl.get(tuple.get(0));
+                result = result * PRIME + objectCodeImpl.get(tuple.get(1));
+                if (tuple.get(0) == tuple.get(1)) {
+                        result += PRIME;
+                        result *= PRIME;
+                }
+                return result;
+        }
+
+        protected long getTupleHashN(Tuple tuple, Object value, ObjectCode objectCodeImpl) {
+                long result = Objects.hashCode(value);
+                for (int i = 0; i < tuple.getSize(); i++) {
+                        result = result * PRIME + objectCodeImpl.get(tuple.get(i));
+                }
+                return result;
+        }
+
+        protected void addHash(ObjectCodeImpl objectCodeImpl, int o, long impact, long tupleHash) {
+                long x = tupleHash * impact;
+                objectCodeImpl.set(o, objectCodeImpl.get(o) + x);
+        }
+
+        protected long calculateModelCode(long lastSum) {
+                long result = 0;
+                for (var nullImpactValue : nullImpactValues) {
+                        result = result * PRIME + Objects.hashCode(((Interpretation<?>) nullImpactValue).get(Tuple0.INSTANCE));
+                }
+                result += lastSum;
+                return result;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/LazyNeighbourhoodCalculator.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/LazyNeighbourhoodCalculator.java
new file mode 100644
index 00000000..c188a839
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/LazyNeighbourhoodCalculator.java
@@ -0,0 +1,193 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.neighbourhood;
+
+import org.eclipse.collections.api.factory.primitive.LongIntMaps;
+import org.eclipse.collections.api.map.primitive.LongIntMap;
+import org.eclipse.collections.api.map.primitive.MutableLongIntMap;
+import org.eclipse.collections.api.set.primitive.IntSet;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.model.AnyInterpretation;
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.statecoding.StateCodeCalculator;
+import tools.refinery.store.statecoding.StateCoderResult;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.List;
+
+public class LazyNeighbourhoodCalculator extends AbstractNeighbourhoodCalculator implements StateCodeCalculator {
+        public LazyNeighbourhoodCalculator(List<? extends AnyInterpretation> interpretations, IntSet individuals) {
+                super(interpretations, individuals);
+        }
+
+        public StateCoderResult calculateCodes() {
+                ObjectCodeImpl previousObjectCode = new ObjectCodeImpl();
+                MutableLongIntMap prevHash2Amount = LongIntMaps.mutable.empty();
+
+                long lastSum;
+                // All hash code is 0, except to the individuals.
+                int lastSize = 1;
+                boolean first = true;
+
+                boolean grows;
+                int rounds = 0;
+                do {
+                        final ObjectCodeImpl nextObjectCode;
+                        if (first) {
+                                nextObjectCode = new ObjectCodeImpl();
+                                initializeWithIndividuals(nextObjectCode);
+                        } else {
+                                nextObjectCode = new ObjectCodeImpl(previousObjectCode);
+                        }
+                        constructNextObjectCodes(previousObjectCode, nextObjectCode, prevHash2Amount);
+
+                        MutableLongIntMap nextHash2Amount = LongIntMaps.mutable.empty();
+                        lastSum = calculateLastSum(previousObjectCode, nextObjectCode, prevHash2Amount, nextHash2Amount);
+
+                        int nextSize = nextHash2Amount.size();
+                        grows = nextSize > lastSize;
+                        lastSize = nextSize;
+                        first = false;
+
+                        previousObjectCode = nextObjectCode;
+                        prevHash2Amount = nextHash2Amount;
+                } while (grows && rounds++ < 4/*&& lastSize < previousObjectCode.getSize()*/);
+
+                long result = calculateModelCode(lastSum);
+
+                return new StateCoderResult((int) result, previousObjectCode);
+        }
+
+        private long calculateLastSum(ObjectCodeImpl previous, ObjectCodeImpl next, LongIntMap hash2Amount,
+                                                                  MutableLongIntMap nextHash2Amount) {
+                long lastSum = 0;
+                for (int i = 0; i < next.getSize(); i++) {
+                        final long hash;
+                        if (isUnique(hash2Amount, previous, i)) {
+                                hash = previous.get(i);
+                                next.set(i, hash);
+                        } else {
+                                hash = next.get(i);
+                        }
+
+                        final int amount = nextHash2Amount.get(hash);
+                        nextHash2Amount.put(hash, amount + 1);
+
+                        final long shifted1 = hash >>> 8;
+                        final long shifted2 = hash << 8;
+                        final long shifted3 = hash >> 2;
+                        lastSum += shifted1 * shifted3 + shifted2;
+                }
+                return lastSum;
+        }
+
+        private void constructNextObjectCodes(ObjectCodeImpl previous, ObjectCodeImpl next, LongIntMap hash2Amount) {
+                for (var impactValueEntry : this.impactValues.entrySet()) {
+                        Interpretation<?> interpretation = (Interpretation<?>) impactValueEntry.getKey();
+                        var cursor = interpretation.getAll();
+                        int arity = interpretation.getSymbol().arity();
+                        long[] impactValue = impactValueEntry.getValue();
+
+                        if (arity == 1) {
+                                while (cursor.move()) {
+                                        lazyImpactCalculation1(hash2Amount, previous, next, impactValue, cursor);
+                                }
+                        } else if (arity == 2) {
+                                while (cursor.move()) {
+                                        lazyImpactCalculation2(hash2Amount, previous, next, impactValue, cursor);
+                                }
+                        } else {
+                                while (cursor.move()) {
+                                        lazyImpactCalculationN(hash2Amount, previous, next, impactValue, cursor);
+                                }
+                        }
+                }
+        }
+
+        private boolean isUnique(LongIntMap hash2Amount, ObjectCodeImpl objectCodeImpl, int object) {
+                final long hash = objectCodeImpl.get(object);
+                if (hash == 0) {
+                        return false;
+                }
+                final int amount = hash2Amount.get(hash);
+                return amount == 1;
+        }
+
+        private void lazyImpactCalculation1(LongIntMap hash2Amount, ObjectCodeImpl previous, ObjectCodeImpl next,
+                                                                                long[] impactValues, Cursor<Tuple, ?> cursor) {
+
+                Tuple tuple = cursor.getKey();
+                int o = tuple.get(0);
+
+                if (isUnique(hash2Amount, previous, o)) {
+                        next.ensureSize(o);
+                } else {
+                        Object value = cursor.getValue();
+                        long tupleHash = getTupleHash1(tuple, value, previous);
+
+                        addHash(next, o, impactValues[0], tupleHash);
+                }
+        }
+
+        private void lazyImpactCalculation2(LongIntMap hash2Amount, ObjectCodeImpl previous, ObjectCodeImpl next,
+                                                                                long[] impactValues, Cursor<Tuple, ?> cursor) {
+                final Tuple tuple = cursor.getKey();
+                final int o1 = tuple.get(0);
+                final int o2 = tuple.get(1);
+
+                final boolean u1 = isUnique(hash2Amount, previous, o1);
+                final boolean u2 = isUnique(hash2Amount, previous, o2);
+
+                if (u1 && u2) {
+                        next.ensureSize(o1);
+                        next.ensureSize(o2);
+                } else {
+                        Object value = cursor.getValue();
+                        long tupleHash = getTupleHash2(tuple, value, previous);
+
+                        if (!u1) {
+                                addHash(next, o1, impactValues[0], tupleHash);
+                                next.ensureSize(o2);
+                        }
+                        if (!u2) {
+                                next.ensureSize(o1);
+                                addHash(next, o2, impactValues[1], tupleHash);
+                        }
+                }
+        }
+
+        private void lazyImpactCalculationN(LongIntMap hash2Amount, ObjectCodeImpl previous, ObjectCodeImpl next,
+                                                                                long[] impactValues, Cursor<Tuple, ?> cursor) {
+                final Tuple tuple = cursor.getKey();
+
+                final boolean[] uniques = new boolean[tuple.getSize()];
+                boolean allUnique = true;
+                for (int i = 0; i < tuple.getSize(); i++) {
+                        final boolean isUnique = isUnique(hash2Amount, previous, tuple.get(i));
+                        uniques[i] = isUnique;
+                        allUnique &= isUnique;
+                }
+
+                if (allUnique) {
+                        for (int i = 0; i < tuple.getSize(); i++) {
+                                next.ensureSize(tuple.get(i));
+                        }
+                } else {
+                        Object value = cursor.getValue();
+                        long tupleHash = getTupleHashN(tuple, value, previous);
+
+                        for (int i = 0; i < tuple.getSize(); i++) {
+                                int o = tuple.get(i);
+                                if (!uniques[i]) {
+                                        addHash(next, o, impactValues[i], tupleHash);
+                                } else {
+                                        next.ensureSize(o);
+                                }
+                        }
+                }
+        }
+
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/NeighbourhoodCalculator.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/NeighbourhoodCalculator.java
new file mode 100644
index 00000000..785fda7a
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/NeighbourhoodCalculator.java
@@ -0,0 +1,115 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.neighbourhood;
+
+import org.eclipse.collections.api.set.primitive.IntSet;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.statecoding.ObjectCode;
+import tools.refinery.store.statecoding.StateCodeCalculator;
+import tools.refinery.store.statecoding.StateCoderResult;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple0;
+
+import java.util.List;
+import java.util.Objects;
+
+public class NeighbourhoodCalculator extends AbstractNeighbourhoodCalculator implements StateCodeCalculator {
+        public NeighbourhoodCalculator(List<? extends Interpretation<?>> interpretations, IntSet individuals) {
+                super(interpretations, individuals);
+        }
+
+        public StateCoderResult calculateCodes() {
+                ObjectCodeImpl previousObjectCode = new ObjectCodeImpl();
+                initializeWithIndividuals(previousObjectCode);
+
+                int rounds = 0;
+                do {
+                        final ObjectCodeImpl nextObjectCode = rounds == 0 ? new ObjectCodeImpl() :
+                                        new ObjectCodeImpl(previousObjectCode.getSize());
+
+                        constructNextObjectCodes(previousObjectCode, nextObjectCode);
+                        previousObjectCode = nextObjectCode;
+                        rounds++;
+                } while (rounds <= 7 && rounds <= previousObjectCode.getEffectiveSize());
+
+                long result = calculateLastSum(previousObjectCode);
+                return new StateCoderResult((int) result, previousObjectCode);
+        }
+
+        private long calculateLastSum(ObjectCode codes) {
+                long result = 0;
+                for (var nullImpactValue : nullImpactValues) {
+                        result = result * 31 + Objects.hashCode(((Interpretation<?>) nullImpactValue).get(Tuple0.INSTANCE));
+                }
+
+                for (int i = 0; i < codes.getSize(); i++) {
+                        final long hash = codes.get(i);
+                        result += hash*PRIME;
+                }
+
+                return result;
+        }
+
+        private void constructNextObjectCodes(ObjectCodeImpl previous, ObjectCodeImpl next) {
+                for (var impactValueEntry : this.impactValues.entrySet()) {
+                        Interpretation<?> interpretation = (Interpretation<?>) impactValueEntry.getKey();
+                        var cursor = interpretation.getAll();
+                        int arity = interpretation.getSymbol().arity();
+                        long[] impactValue = impactValueEntry.getValue();
+
+                        if (arity == 1) {
+                                while (cursor.move()) {
+                                        impactCalculation1(previous, next, impactValue, cursor);
+                                }
+                        } else if (arity == 2) {
+                                while (cursor.move()) {
+                                        impactCalculation2(previous, next, impactValue, cursor);
+                                }
+                        } else {
+                                while (cursor.move()) {
+                                        impactCalculationN(previous, next, impactValue, cursor);
+                                }
+                        }
+                }
+        }
+
+
+        private void impactCalculation1(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues,
+                                                                        Cursor<Tuple, ?> cursor) {
+
+                Tuple tuple = cursor.getKey();
+                int o = tuple.get(0);
+                Object value = cursor.getValue();
+                long tupleHash = getTupleHash1(tuple, value, previous);
+                addHash(next, o, impactValues[0], tupleHash);
+        }
+
+        private void impactCalculation2(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues,
+                                                                        Cursor<Tuple, ?> cursor) {
+                final Tuple tuple = cursor.getKey();
+                final int o1 = tuple.get(0);
+                final int o2 = tuple.get(1);
+
+                Object value = cursor.getValue();
+                long tupleHash = getTupleHash2(tuple, value, previous);
+
+                addHash(next, o1, impactValues[0], tupleHash);
+                addHash(next, o2, impactValues[1], tupleHash);
+        }
+
+        private void impactCalculationN(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues,
+                                                                        Cursor<Tuple, ?> cursor) {
+                final Tuple tuple = cursor.getKey();
+
+                Object value = cursor.getValue();
+                long tupleHash = getTupleHashN(tuple, value, previous);
+
+                for (int i = 0; i < tuple.getSize(); i++) {
+                        addHash(next, tuple.get(i), impactValues[i], tupleHash);
+                }
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/ObjectCodeImpl.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/ObjectCodeImpl.java
new file mode 100644
index 00000000..0cd7ff58
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/ObjectCodeImpl.java
@@ -0,0 +1,81 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.neighbourhood;
+
+import tools.refinery.store.statecoding.ObjectCode;
+
+import java.util.Arrays;
+
+public class ObjectCodeImpl implements ObjectCode {
+        private long[] vector;
+        private int size;
+        private int effectiveSize;
+
+        public ObjectCodeImpl() {
+                vector = new long[10];
+                size = 0;
+                effectiveSize = 0;
+        }
+
+        public ObjectCodeImpl(int size) {
+                this.vector = new long[size];
+                this.size = size;
+                effectiveSize = 0;
+        }
+
+        public ObjectCodeImpl(ObjectCodeImpl copy) {
+                this.vector = Arrays.copyOf(copy.vector, copy.size);
+                this.size = copy.size;
+                effectiveSize = copy.effectiveSize;
+        }
+
+        public void ensureSize(int object) {
+                if (object >= size) {
+                        size = object + 1;
+                }
+
+                if (object >= vector.length) {
+                        int newLength = vector.length * 2;
+                        while (object >= newLength) {
+                                newLength *= 2;
+                        }
+
+                        long[] newVector = new long[newLength];
+                        System.arraycopy(vector, 0, newVector, 0, vector.length);
+                        this.vector = newVector;
+                }
+        }
+
+        public long get(int object) {
+                if (object < vector.length) {
+                        return vector[object];
+                } else {
+                        return 0;
+                }
+        }
+
+        public void set(int object, long value) {
+                ensureSize(object);
+                final long valueToPut = value == 0 ? 1 : value;
+                if (vector[object] == 0) effectiveSize++;
+                vector[object] = valueToPut;
+        }
+
+        public int getSize() {
+                return this.size;
+        }
+
+        public int getEffectiveSize() {
+                return this.effectiveSize;
+        }
+
+        @Override
+        public String toString() {
+                return "ObjectCodeImpl{" +
+                                "vector=" + Arrays.toString(Arrays.copyOf(vector, this.size)) +
+                                '}';
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/CombinationNodePairing.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/CombinationNodePairing.java
new file mode 100644
index 00000000..0682e1a4
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/CombinationNodePairing.java
@@ -0,0 +1,89 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.stateequivalence;
+
+import org.eclipse.collections.api.factory.primitive.IntIntMaps;
+import org.eclipse.collections.api.map.primitive.IntIntMap;
+import org.eclipse.collections.api.set.primitive.IntSet;
+
+import java.util.*;
+
+public class CombinationNodePairing implements NodePairing {
+        private final int[] left;
+        private final int[] right;
+
+        CombinationNodePairing(IntSet left, IntSet right) {
+                this.left = left.toArray();
+                this.right = right.toArray();
+
+                Arrays.sort(this.left);
+                Arrays.sort(this.right);
+        }
+
+        @Override
+        public int size() {
+                return left.length;
+        }
+
+        private static final int LIMIT = 5;
+        // Enum-based singleton used to delay generating all permutations until they are first needed.
+        @SuppressWarnings("squid:S6548")
+        private enum PermutationsHolder {
+                INSTANCE;
+
+                final CombinationNodePairingPermutations permutations = new CombinationNodePairingPermutations(LIMIT);
+        }
+
+        @Override
+        public List<IntIntMap> permutations() {
+                int limit = this.size();
+                Iterable<Integer> interval = () -> new IntervalIterator(limit);
+
+                if (isComplete()) {
+                        final List<int[]> p = PermutationsHolder.INSTANCE.permutations.getPermutations(this.size() - 1);
+                        return p.stream().map(x -> constructPermutationMap(interval, x)).toList();
+                } else {
+                        return List.of(constructTrivialMap(interval));
+                }
+        }
+
+        private IntIntMap constructTrivialMap(Iterable<Integer> interval) {
+                return IntIntMaps.immutable.from(interval, l -> left[l], r -> right[r]);
+        }
+
+        private IntIntMap constructPermutationMap(Iterable<Integer> interval, int[] permutation) {
+                return IntIntMaps.immutable.from(interval, l -> left[l], r -> right[permutation[r]]);
+        }
+
+        @Override
+        public boolean isComplete() {
+                return this.size() <= LIMIT;
+        }
+
+        private static class IntervalIterator implements Iterator<Integer> {
+                private final int limit;
+                private int value = 0;
+
+                private IntervalIterator(int max) {
+                        this.limit = max;
+                }
+
+                @Override
+                public boolean hasNext() {
+                        return value < limit;
+                }
+
+                @Override
+                public Integer next() {
+                        if (value >= limit) {
+                                throw new NoSuchElementException("End of interval");
+                        }
+                        int next = value;
+                        value++;
+                        return next;
+                }
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/CombinationNodePairingPermutations.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/CombinationNodePairingPermutations.java
new file mode 100644
index 00000000..eacd3a2a
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/CombinationNodePairingPermutations.java
@@ -0,0 +1,57 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.stateequivalence;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class CombinationNodePairingPermutations {
+        private final List<List<int[]>> permutations = new ArrayList<>();
+
+        public CombinationNodePairingPermutations(int max) {
+                initializePermutations(max);
+        }
+
+        public List<int[]> getPermutations(int max) {
+                if (max >= permutations.size()) {
+                        throw new IllegalArgumentException("Only permutations up to %d elements are supported".formatted(max));
+                }
+                return permutations.get(max);
+        }
+
+        /**
+         * Generates and stores permutations up to a given size. If the number would be more than a limit, it provides a
+         * single permutation only.
+         *
+         * @param max The max number in the permutation
+         * @return A complete list of permutations of numbers 0...max, or a single permutation.
+         */
+        private List<int[]> initializePermutations(int max) {
+                if (max < permutations.size()) {
+                        return permutations.get(max);
+                }
+                if (max == 0) {
+                        List<int[]> result = new ArrayList<>();
+                        result.add(new int[1]);
+                        permutations.add(result);
+                        return result;
+                }
+                List<int[]> result = new ArrayList<>();
+                List<int[]> previousPermutations = initializePermutations(max - 1);
+                for (var permutation : previousPermutations) {
+                        for (int pos = 0; pos <= max; pos++) {
+                                int[] newPermutation = new int[max + 1];
+                                System.arraycopy(permutation, 0, newPermutation, 0, pos);
+                                newPermutation[pos] = max;
+                                if (max - (pos + 1) >= 0)
+                                        System.arraycopy(permutation, pos + 1, newPermutation, pos + 1 + 1, max - (pos + 1));
+                                result.add(newPermutation);
+                        }
+                }
+                permutations.add(result);
+                return result;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/NodePairing.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/NodePairing.java
new file mode 100644
index 00000000..f45f0d2e
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/NodePairing.java
@@ -0,0 +1,33 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.stateequivalence;
+
+import org.eclipse.collections.api.map.primitive.IntIntMap;
+import org.eclipse.collections.api.set.primitive.IntSet;
+
+import java.util.List;
+
+public interface NodePairing {
+        int size();
+
+        List<IntIntMap> permutations();
+
+        boolean isComplete();
+
+        static NodePairing constructNodePairing(IntSet left, IntSet right){
+                if(left.size() !=  right.size()) {
+                        return null;
+                }
+
+                if(left.size() == 1) {
+                        int leftValue = left.intIterator().next();
+                        int rightValue = right.intIterator().next();
+                        return new TrivialNodePairing(leftValue, rightValue);
+                } else {
+                        return new CombinationNodePairing(left,right);
+                }
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/PermutationMorphism.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/PermutationMorphism.java
new file mode 100644
index 00000000..bc4d723a
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/PermutationMorphism.java
@@ -0,0 +1,64 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.stateequivalence;
+
+import org.eclipse.collections.api.map.primitive.IntIntMap;
+import tools.refinery.store.statecoding.Morphism;
+
+import java.util.List;
+
+public class PermutationMorphism implements Morphism {
+        private final IntIntMap object2PermutationGroup;
+        private final List<? extends List<? extends IntIntMap>> permutationsGroups;
+        private final int[] selection;
+        private boolean hasNext;
+
+        PermutationMorphism(IntIntMap object2PermutationGroup,
+                                                List<? extends List<? extends IntIntMap>> permutationsGroups) {
+                this.object2PermutationGroup = object2PermutationGroup;
+                this.permutationsGroups = permutationsGroups;
+
+                this.selection = new int[this.permutationsGroups.size()];
+                this.hasNext = true;
+        }
+
+        public boolean next() {
+                return next(0);
+        }
+
+        private boolean next(int position) {
+                if (position >= permutationsGroups.size()) {
+                        this.hasNext = false;
+                        return false;
+                }
+                if (selection[position] + 1 < permutationsGroups.get(position).size()) {
+                        selection[position] = selection[position] + 1;
+                        return true;
+                } else {
+                        selection[position] = 0;
+                        return next(position + 1);
+                }
+        }
+
+        @Override
+        public int get(int object) {
+                if(!hasNext) {
+                        throw new IllegalArgumentException("No next permutation!");
+                }
+
+                final int groupIndex = object2PermutationGroup.get(object);
+                final var selectedGroup = permutationsGroups.get(groupIndex);
+                final int permutationIndex = selection[groupIndex];
+                final var selectedPermutation = selectedGroup.get(permutationIndex);
+
+                return selectedPermutation.get(object);
+        }
+
+        @Override
+        public int getSize() {
+                return object2PermutationGroup.size();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/StateEquivalenceCheckerImpl.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/StateEquivalenceCheckerImpl.java
new file mode 100644
index 00000000..5a62d8a0
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/StateEquivalenceCheckerImpl.java
@@ -0,0 +1,166 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.stateequivalence;
+
+import org.eclipse.collections.api.factory.primitive.IntIntMaps;
+import org.eclipse.collections.api.factory.primitive.IntSets;
+import org.eclipse.collections.api.factory.primitive.LongObjectMaps;
+import org.eclipse.collections.api.map.primitive.IntIntMap;
+import org.eclipse.collections.api.map.primitive.MutableIntIntMap;
+import org.eclipse.collections.api.map.primitive.MutableLongObjectMap;
+import org.eclipse.collections.api.set.primitive.IntSet;
+import org.eclipse.collections.api.set.primitive.MutableIntSet;
+import tools.refinery.store.model.AnyInterpretation;
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.statecoding.Morphism;
+import tools.refinery.store.statecoding.ObjectCode;
+import tools.refinery.store.statecoding.StateEquivalenceChecker;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public class StateEquivalenceCheckerImpl implements StateEquivalenceChecker {
+        public static final int LIMIT = 1000;
+
+        @Override
+        public EquivalenceResult constructMorphism(IntSet individuals,
+                                                                                           List<? extends AnyInterpretation> interpretations1,
+                                                                                           ObjectCode code1,
+                                                                                           List<? extends AnyInterpretation> interpretations2,
+                                                                                           ObjectCode code2) {
+                MutableIntIntMap object2PermutationGroup = IntIntMaps.mutable.empty();
+                List<List<IntIntMap>> permutationsGroups = new ArrayList<>();
+
+                final EquivalenceResult permutations = constructPermutationNavigation(individuals,
+                                indexByHash(code1, individuals), indexByHash(code2, individuals),
+                                object2PermutationGroup, permutationsGroups);
+
+                if (permutations == EquivalenceResult.DIFFERENT) {
+                        return EquivalenceResult.DIFFERENT;
+                }
+
+                boolean hasNext;
+                PermutationMorphism morphism = new PermutationMorphism(object2PermutationGroup, permutationsGroups);
+                int tried = 0;
+                do {
+                        if (testMorphism(interpretations1, interpretations2, morphism)) {
+                                return permutations;
+                        }
+
+                        if (tried >= LIMIT) {
+                                return EquivalenceResult.UNKNOWN;
+                        }
+
+                        hasNext = morphism.next();
+                        tried++;
+                } while (hasNext);
+
+                if (permutations == EquivalenceResult.UNKNOWN) {
+                        return EquivalenceResult.UNKNOWN;
+                } else {
+                        return EquivalenceResult.DIFFERENT;
+                }
+        }
+
+        private MutableLongObjectMap<MutableIntSet> indexByHash(ObjectCode code, IntSet individuals) {
+                MutableLongObjectMap<MutableIntSet> result = LongObjectMaps.mutable.empty();
+                for (int o = 0; o < code.getSize(); o++) {
+                        if (!individuals.contains(o)) {
+                                long hash = code.get(o);
+                                if (hash != 0) {
+                                        var equivalenceClass = result.get(hash);
+                                        if (equivalenceClass == null) {
+                                                equivalenceClass = IntSets.mutable.empty();
+                                                result.put(hash, equivalenceClass);
+                                        }
+                                        equivalenceClass.add(o);
+                                }
+                        }
+                }
+                return result;
+        }
+
+        private EquivalenceResult constructPermutationNavigation(
+                        IntSet individuals, MutableLongObjectMap<MutableIntSet> map1, MutableLongObjectMap<MutableIntSet> map2,
+                        MutableIntIntMap object2OptionIndex, List<List<IntIntMap>> listOfOptions) {
+                if (map1.size() != map2.size()) {
+                        return EquivalenceResult.DIFFERENT;
+                }
+
+                var iterator = map1.keySet().longIterator();
+
+                boolean allComplete = true;
+
+                while (iterator.hasNext()) {
+                        long hash = iterator.next();
+                        var set1 = map1.get(hash);
+                        var set2 = map2.get(hash);
+                        if (set2 == null) {
+                                return EquivalenceResult.DIFFERENT;
+                        }
+
+                        var pairing = NodePairing.constructNodePairing(set1, set2);
+                        if (pairing == null) {
+                                return EquivalenceResult.DIFFERENT;
+                        }
+
+                        allComplete &= pairing.isComplete();
+
+                        final int optionIndex = listOfOptions.size();
+                        set1.forEach(key -> object2OptionIndex.put(key, optionIndex));
+                        listOfOptions.add(pairing.permutations());
+                }
+
+                individuals.forEach(o -> listOfOptions.add(o, List.of(IntIntMaps.immutable.of(o, o))));
+
+                if (allComplete) {
+                        return EquivalenceResult.ISOMORPHIC;
+                } else {
+                        return EquivalenceResult.UNKNOWN;
+                }
+        }
+
+        private boolean testMorphism(List<? extends AnyInterpretation> s, List<? extends AnyInterpretation> t,
+                                                                 Morphism m) {
+                for (int interpretationIndex = 0; interpretationIndex < s.size(); interpretationIndex++) {
+                        var sI = s.get(interpretationIndex);
+                        var tI = t.get(interpretationIndex);
+
+                        var cursor = ((Interpretation<?>) sI).getAll();
+                        while (cursor.move()) {
+                                final Tuple sTuple = cursor.getKey();
+                                final Object sValue = cursor.getValue();
+
+                                final Tuple tTuple = apply(sTuple, m);
+                                final Object tValue = ((Interpretation<?>) tI).get(tTuple);
+
+                                if (!Objects.equals(sValue, tValue)) {
+                                        return false;
+                                }
+                        }
+                }
+                return true;
+        }
+
+        private Tuple apply(Tuple t, Morphism m) {
+                final int arity = t.getSize();
+                if (arity == 0) {
+                        return Tuple.of();
+                } else if (arity == 1) {
+                        return Tuple.of(m.get(t.get(0)));
+                } else if (arity == 2) {
+                        return Tuple.of(m.get(t.get(0)), m.get(t.get(1)));
+                } else {
+                        int[] newTupleIndices = new int[arity];
+                        for (int i = 0; i < arity; i++) {
+                                newTupleIndices[i] = m.get(t.get(i));
+                        }
+                        return Tuple.of(newTupleIndices);
+                }
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/TrivialNodePairing.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/TrivialNodePairing.java
new file mode 100644
index 00000000..f5eadfb9
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/TrivialNodePairing.java
@@ -0,0 +1,36 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.stateequivalence;
+
+import org.eclipse.collections.api.factory.primitive.IntIntMaps;
+import org.eclipse.collections.api.map.primitive.IntIntMap;
+
+import java.util.List;
+
+public class TrivialNodePairing implements NodePairing {
+        final int left;
+        final int right;
+
+        TrivialNodePairing(int left, int right) {
+                this.left = left;
+                this.right = right;
+        }
+
+        @Override
+        public int size() {
+                return 1;
+        }
+
+        @Override
+        public List<IntIntMap> permutations() {
+                return List.of(IntIntMaps.immutable.of(left,right));
+        }
+
+        @Override
+        public boolean isComplete() {
+                return true;
+        }
+}
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/InOrderCursorTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/InOrderCursorTest.java
new file mode 100644
index 00000000..98756460
--- /dev/null
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/InOrderCursorTest.java
@@ -0,0 +1,56 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.tests;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
+import tools.refinery.store.map.internal.state.InOrderMapCursor;
+import tools.refinery.store.map.internal.state.VersionedMapStateImpl;
+import tools.refinery.store.map.tests.utils.MapTestEnvironment;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class InOrderCursorTest {
+        @Test
+        void testCursor() {
+                var store = VersionedMapStore.<Integer,String>builder()
+                                .strategy(VersionedMapStoreFactoryBuilder.StoreStrategy.STATE)
+                                .stateBasedImmutableWhenCommitting(true)
+                                .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE)
+                                .defaultValue("x")
+                                .build()
+                                .createOne();
+
+                VersionedMapStateImpl<Integer,String> map = (VersionedMapStateImpl<Integer,String>) store.createMap();
+                checkMove(map,0);
+
+                map.put(1,"A");
+                map.commit();
+                checkMove(map,1);
+
+
+                map.put(2,"B");
+                map.commit();
+                checkMove(map,2);
+
+                map.put(3,"C");
+                map.commit();
+                checkMove(map,3);
+
+        }
+
+        private void checkMove(VersionedMapStateImpl<Integer,String> map, int num) {
+                InOrderMapCursor<Integer,String> cursor = new InOrderMapCursor<>(map);
+                for(int i=0; i<num; i++) {
+                        assertTrue(cursor.move());
+                        assertFalse(cursor.isTerminated());
+                }
+                assertFalse(cursor.move());
+                assertTrue(cursor.isTerminated());
+        }
+}
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java
index 153f2e78..cc2e425c 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java
@@ -7,7 +7,7 @@ package tools.refinery.store.map.tests;
 
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
+import tools.refinery.store.map.internal.state.VersionedMapStoreStateImpl;
 import tools.refinery.store.model.TupleHashProvider;
 import tools.refinery.store.tuple.Tuple;
 
@@ -16,11 +16,82 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 class MapUnitTests {
         @Test
         void defaultTest() {
-                VersionedMapStore<Tuple, Boolean> store = new VersionedMapStoreImpl<>(TupleHashProvider.INSTANCE, false);
+                VersionedMapStore<Tuple, Boolean> store = new VersionedMapStoreStateImpl<>(TupleHashProvider.INSTANCE, false);
                 var map = store.createMap();
                 var out1 = map.put(Tuple.of(0), true);
                 assertEquals(false, out1);
                 var out2 = map.put(Tuple.of(1), true);
                 assertEquals(false, out2);
         }
+
+        @Test
+        void deltaRestoreTest() {
+                VersionedMapStore<Integer,String> store =
+                                VersionedMapStore.<Integer,String>builder().defaultValue("x").build().createOne();
+                var map = store.createMap();
+                map.put(1,"val");
+                var version1 = map.commit();
+                map.put(1,"x");
+                map.restore(version1);
+                System.out.println(map.getSize());
+                assertEquals(1,map.getSize());
+        }
+
+        @Test
+        void deltaRestoreTest2() {
+                VersionedMapStore<Integer,String> store =
+                                VersionedMapStore.<Integer,String>builder().defaultValue("x").build().createOne();
+                var map = store.createMap();
+                map.put(1,"x");
+                var version1 = map.commit();
+                map.put(1,"1");
+                map.restore(version1);
+                System.out.println(map.getSize());
+                assertEquals(0,map.getSize());
+        }
+        @Test
+        void deltaRestoreTest3() {
+                VersionedMapStore<Integer,String> store =
+                                VersionedMapStore.<Integer,String>builder().defaultValue("x").build().createOne();
+                var map = store.createMap();
+                map.commit();
+                map.put(1,"1");
+                map.put(2,"x");
+                assertEquals(1,map.getSize());
+                var version1 = map.commit();
+                map.put(1,"x");
+                assertEquals(0,map.getSize());
+                map.put(2,"2");
+                assertEquals(1,map.getSize());
+                map.put(2,"x");
+                assertEquals(0,map.getSize());
+                var version2 = map.commit();
+                map.restore(version1);
+                assertEquals(1,map.getSize());
+                map.restore(version2);
+                assertEquals(0,map.getSize());
+        }
+
+        @Test
+        void deltaRestoreTest4() {
+                VersionedMapStore<Integer,String> store =
+                                VersionedMapStore.<Integer,String>builder().defaultValue("x").build().createOne();
+                var map = store.createMap();
+                map.commit();
+                map.put(1,"1");
+                map.put(2,"x");
+                assertEquals(1,map.getSize());
+                var version1 = map.commit();
+                map.put(1,"x");
+                assertEquals(0,map.getSize());
+                map.put(2,"2");
+                assertEquals(1,map.getSize());
+                map.put(2,"x");
+                assertEquals(0,map.getSize());
+                var version2 = map.commit();
+                map.restore(version1);
+                assertEquals(1,map.getSize());
+                map.restore(version2);
+                assertEquals(0,map.getSize());
+        }
 }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java
index eabe5bd1..58206eda 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java
@@ -5,33 +5,32 @@
  */
 package tools.refinery.store.map.tests.fuzz;
 
-import static org.junit.jupiter.api.Assertions.fail;
-
-import java.util.Random;
-import java.util.stream.Stream;
-
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-
-import tools.refinery.store.map.ContinousHashProvider;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
+import java.util.Random;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.fail;
+import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
+
 class CommitFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
-                        boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
-                VersionedMapImpl<Integer, String> sut = (VersionedMapImpl<Integer, String>) store.createMap();
-                MapTestEnvironment<Integer, String> e = new MapTestEnvironment<Integer, String>(sut);
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, int commitFrequency,
+                                                         VersionedMapStoreFactoryBuilder<Integer, String> builder) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
+
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
+                var sut = store.createMap();
+                MapTestEnvironment<Integer, String> e = new MapTestEnvironment<>(sut);
 
                 Random r = new Random(seed);
 
@@ -39,24 +38,13 @@ class CommitFuzzTest {
         }
 
         private void iterativeRandomPutsAndCommits(String scenario, int steps, int maxKey, String[] values,
-                        MapTestEnvironment<Integer, String> e, Random r, int commitFrequency) {
-                int stopAt = -1;
+                                                                                           MapTestEnvironment<Integer, String> e, Random r, int commitFrequency) {
                 for (int i = 0; i < steps; i++) {
                         int index = i + 1;
                         int nextKey = r.nextInt(maxKey);
                         String nextValue = values[r.nextInt(values.length)];
-                        if (index == stopAt) {
-                                System.out.println("issue!");
-                                System.out.println("State before:");
-                                e.printComparison();
-                                e.sut.prettyPrint();
-                                System.out.println("Next: put(" + nextKey + "," + nextValue + ")");
-                        }
                         try {
                                 e.put(nextKey, nextValue);
-                                if (index == stopAt) {
-                                        e.sut.prettyPrint();
-                                }
                                 e.checkEquivalence(scenario + ":" + index);
                         } catch (Exception exception) {
                                 exception.printStackTrace();
@@ -64,35 +52,37 @@ class CommitFuzzTest {
                         }
                         MapTestEnvironment.printStatus(scenario, index, steps, null);
                         if (index % commitFrequency == 0) {
-                                e.sut.commit();
+                                e.commit();
                         }
                 }
         }
 
-        @ParameterizedTest(name = "Commit {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        public static final String title = "Commit {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5} " +
+                        "seed={6} config={7}";
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
-        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
-                return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
-                                new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
+                                commitFrequencyOptions, randomSeedOptions, storeConfigs);
         }
 
-        @ParameterizedTest(name = "Commit {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = title)
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java
index b0502a2b..c49911b8 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java
@@ -10,8 +10,10 @@ import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import tools.refinery.store.map.*;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.VersionedMap;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
@@ -22,23 +24,25 @@ import java.util.List;
 import java.util.Random;
 import java.util.stream.Stream;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.fail;
+import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
 
 class ContentEqualsFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
-                                                         boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, int commitFrequency,
+                                                         VersionedMapStoreFactoryBuilder<Integer, String> builder) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
+
 
                 Random r = new Random(seed);
 
-                iterativeRandomPutsAndCommitsThenCompare(scenario, chp, steps, maxKey, values, r, commitFrequency);
+                iterativeRandomPutsAndCommitsThenCompare(scenario, builder, steps, maxKey, values, r, commitFrequency);
         }
 
-        private void iterativeRandomPutsAndCommitsThenCompare(String scenario, ContinousHashProvider<Integer> chp,
+        private void iterativeRandomPutsAndCommitsThenCompare(String scenario, VersionedMapStoreFactoryBuilder<Integer, String> builder,
                                                                                                                   int steps, int maxKey, String[] values, Random r,
                                                                                                                   int commitFrequency) {
-                VersionedMapStore<Integer, String> store1 = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
+                VersionedMapStore<Integer, String> store1 = builder.defaultValue(values[0]).build().createOne();
                 VersionedMap<Integer, String> sut1 = store1.createMap();
 
                 // Fill one map
@@ -68,7 +72,7 @@ class ContentEqualsFuzzTest {
                 // Randomize the order of the content
                 Collections.shuffle(content, r);
 
-                VersionedMapStore<Integer, String> store2 = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
+                VersionedMapStore<Integer, String> store2 = builder.defaultValue(values[0]).build().createOne();
                 VersionedMap<Integer, String> sut2 = store2.createMap();
                 int index2 = 1;
                 for (SimpleEntry<Integer, String> entry : content) {
@@ -78,40 +82,39 @@ class ContentEqualsFuzzTest {
                 }
 
                 // Check the integrity of the maps
-                ((VersionedMapImpl<Integer, String>) sut1).checkIntegrity();
-                ((VersionedMapImpl<Integer, String>) sut2).checkIntegrity();
+                sut1.checkIntegrity();
+                sut2.checkIntegrity();
 
                 // Compare the two maps
                 MapTestEnvironment.compareTwoMaps(scenario, sut1, sut2);
         }
 
-        @ParameterizedTest(name = "Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} " +
-                        "evil-hash={6}")
+        public static final String title = "Compare {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit frequency={5}" +
+                        "seed={6} config={7}";
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
-        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                                                          boolean evilHash) {
+        void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
-                return FuzzTestUtils.permutationWithSize(new Object[]{FuzzTestUtils.FAST_STEP_COUNT}, new Object[]{3, 32,
-                                                32 * 32},
-                                new Object[]{2, 3}, new Object[]{1, 10, 100}, new Object[]{1, 2, 3},
-                                new Object[]{false, true});
+                return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
+                                commitFrequencyOptions, randomSeedOptions, storeConfigs);
         }
 
-        @ParameterizedTest(name = "Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} " +
-                        "evil-hash={6}")
+        @ParameterizedTest(name = title)
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                                                          boolean evilHash) {
+        void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull, int commitFrequency,
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                defaultNull, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java
index 8274336e..94259edc 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java
@@ -5,115 +5,134 @@
  */
 package tools.refinery.store.map.tests.fuzz;
 
-import static org.junit.jupiter.api.Assertions.fail;
-
-import java.util.Random;
-import java.util.stream.Stream;
-
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-
-import tools.refinery.store.map.ContinousHashProvider;
-import tools.refinery.store.map.DiffCursor;
-import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.*;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.fail;
+import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
+
 class DiffCursorFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
-                        boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault,
+                                                         int commitFrequency, boolean commitBeforeDiffCursor,
+                                                         VersionedMapStoreFactoryBuilder<Integer, String> builder) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
-                iterativeRandomPutsAndCommitsThenDiffcursor(scenario, store, steps, maxKey, values, seed, commitFrequency);
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
+                iterativeRandomPutsAndCommitsThenDiffCursor(scenario, store, steps, maxKey, values, seed, commitFrequency,
+                                commitBeforeDiffCursor);
         }
 
-        private void iterativeRandomPutsAndCommitsThenDiffcursor(String scenario, VersionedMapStore<Integer, String> store,
-                        int steps, int maxKey, String[] values, int seed, int commitFrequency) {
-                // 1. build a map with versions
-                Random r = new Random(seed);
-                VersionedMapImpl<Integer, String> versioned = (VersionedMapImpl<Integer, String>) store.createMap();
+        private void iterativeRandomPutsAndCommitsThenDiffCursor(String scenario, VersionedMapStore<Integer, String> store,
+                                                                                                                         int steps, int maxKey, String[] values, int seed,
+                                                                                                                         int commitFrequency, boolean commitBeforeDiffCursor) {
+
                 int largestCommit = -1;
+                Map<Integer,Version> index2Version = new HashMap<>();
 
-                for (int i = 0; i < steps; i++) {
-                        int index = i + 1;
-                        int nextKey = r.nextInt(maxKey);
-                        String nextValue = values[r.nextInt(values.length)];
-                        try {
-                                versioned.put(nextKey, nextValue);
-                        } catch (Exception exception) {
-                                exception.printStackTrace();
-                                fail(scenario + ":" + index + ": exception happened: " + exception);
-                        }
-                        if (index % commitFrequency == 0) {
-                                long version = versioned.commit();
-                                largestCommit = (int) version;
-                        }
-                        if (index % 10000 == 0)
-                                System.out.println(scenario + ":" + index + "/" + steps + " building finished");
-                }
-                // 2. create a non-versioned map,
-                VersionedMapImpl<Integer, String> moving = (VersionedMapImpl<Integer, String>) store.createMap();
-                Random r2 = new Random(seed + 1);
-
-                final int diffTravelFrequency = commitFrequency * 2;
-                for (int i = 0; i < steps; i++) {
-                        int index = i + 1;
-                        if (index % diffTravelFrequency == 0) {
-                                // difftravel
-                                long travelToVersion = r2.nextInt(largestCommit + 1);
-                                DiffCursor<Integer, String> diffCursor = moving.getDiffCursor(travelToVersion);
-                                moving.putAll(diffCursor);
-
-                        } else {
-                                // random puts
-                                int nextKey = r2.nextInt(maxKey);
-                                String nextValue = values[r2.nextInt(values.length)];
+                {
+                        // 1. build a map with versions
+                        Random r = new Random(seed);
+                        VersionedMap<Integer, String> versioned = store.createMap();
+                        for (int i = 0; i < steps; i++) {
+                                int index = i + 1;
+                                int nextKey = r.nextInt(maxKey);
+                                String nextValue = values[r.nextInt(values.length)];
                                 try {
-                                        moving.put(nextKey, nextValue);
+                                        versioned.put(nextKey, nextValue);
                                 } catch (Exception exception) {
                                         exception.printStackTrace();
                                         fail(scenario + ":" + index + ": exception happened: " + exception);
                                 }
                                 if (index % commitFrequency == 0) {
-                                        versioned.commit();
+                                        Version version = versioned.commit();
+                                        index2Version.put(index,version);
+                                        largestCommit = index;
                                 }
                                 if (index % 10000 == 0)
                                         System.out.println(scenario + ":" + index + "/" + steps + " building finished");
                         }
                 }
 
+                {
+                        // 2. create a non-versioned map,
+                        VersionedMap<Integer, String> moving = store.createMap();
+                        Random r2 = new Random(seed + 1);
+
+                        final int diffTravelFrequency = commitFrequency * 2;
+                        for (int i = 0; i < steps; i++) {
+                                int index = i + 1;
+                                if (index % diffTravelFrequency == 0) {
+                                        // diff-travel
+                                        int travelToVersion = r2.nextInt(largestCommit + 1);
+
+                                        VersionedMap<Integer, String> oracle = store.createMap(index2Version.get(travelToVersion));
+
+                                        if(commitBeforeDiffCursor) {
+                                                moving.commit();
+                                        }
+                                        DiffCursor<Integer, String> diffCursor = moving.getDiffCursor(index2Version.get(travelToVersion));
+                                        moving.putAll(diffCursor);
+                                        moving.commit();
+
+                                        MapTestEnvironment.compareTwoMaps(scenario + ":c" + index, oracle, moving);
+
+                                        moving.restore(index2Version.get(travelToVersion));
+
+                                } else {
+                                        // random puts
+                                        int nextKey = r2.nextInt(maxKey);
+                                        String nextValue = values[r2.nextInt(values.length)];
+                                        try {
+                                                moving.put(nextKey, nextValue);
+                                        } catch (Exception exception) {
+                                                exception.printStackTrace();
+                                                fail(scenario + ":" + index + ": exception happened: " + exception);
+                                        }
+                                        if (index % 10000 == 0)
+                                                System.out.println(scenario + ":" + index + "/" + steps + " building finished");
+                                }
+                        }
+                }
         }
 
-        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        public static final String title = "DiffCursor {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " +
+                        "commit frequency={5} seed={6} commit before diff={7} config={8}";
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
-        void parametrizedFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
-                runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
-                                noKeys, noValues, commitFrequency, evilHash);
+        void parametrizedFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault,
+                                                  int commitFrequency, int seed, boolean commitBeforeDiffCursor,
+                                                  VersionedMapStoreFactoryBuilder<Integer, String> builder) {
+                runFuzzTest("DiffCursorS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
+                                noKeys, noValues, nullDefault, commitFrequency, commitBeforeDiffCursor, builder);
         }
 
         static Stream<Arguments> parametrizedFuzz() {
-                return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
-                                new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                return FuzzTestUtils.permutationWithSize(new Object[]{100}, keyCounts, valueCounts, nullDefaultOptions,
+                                commitFrequencyOptions, randomSeedOptions, new Object[]{false,true}, storeConfigs);
         }
-        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
-                runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+        void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                        int seed, boolean commitBeforeDiffCursor, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
+                runFuzzTest("DiffCursorS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
+                                nullDefault, commitFrequency, commitBeforeDiffCursor, builder);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java
index ab2b9435..3b55434c 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java
@@ -5,95 +5,96 @@
  */
 package tools.refinery.store.map.tests.fuzz;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.fail;
-
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.stream.Stream;
-
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-
-import tools.refinery.store.map.ContinousHashProvider;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
+
 class MultiThreadFuzzTest {
-        public static final int noThreads = 32;
-        
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
-                        boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
-
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
-                
+        public static final int noThreads = 10;
+
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault, int commitFrequency, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
+
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
+
                 // initialize runnables
                 MultiThreadTestRunnable[] runnables = new MultiThreadTestRunnable[noThreads];
-                for(int i = 0; i<noThreads; i++) {
-                        runnables[i] = new MultiThreadTestRunnable(scenario+"-T"+(i+1), store, steps, maxKey, values, seed, commitFrequency);
+                for (int i = 0; i < noThreads; i++) {
+                        runnables[i] = new MultiThreadTestRunnable(scenario + "-T" + (i + 1), store, steps, maxKey, values, seed
+                                         , commitFrequency);
                 }
-                
+
                 // initialize threads
                 Thread[] threads = new Thread[noThreads];
-                for(int i = 0; i<noThreads; i++) {
+                for (int i = 0; i < noThreads; i++) {
                         threads[i] = new Thread(runnables[i]);
                 }
-                
+
                 // start threads;
-                for(int i = 0; i<noThreads; i++) {
-                        threads[i].start();
+                for (int i = 0; i < noThreads; i++) {
+                        runnables[i].run();
+                        //threads[i].start();
                 }
-                
+
                 // wait all the threads;
-                for(int i = 0; i<noThreads; i++) {
+                for (int i = 0; i < noThreads; i++) {
                         try {
                                 threads[i].join();
                         } catch (InterruptedException e) {
-                                fail("Thread "+i+" interrupted.");
+                                fail("Thread " + i + " interrupted.");
                         }
                 }
-                
+
                 // collect errors
                 List<Throwable> errors = new LinkedList<>();
-                for(int i = 0; i<noThreads; i++) {
+                for (int i = 0; i < noThreads; i++) {
                         errors.addAll(runnables[i].getErrors());
                 }
-                
+
                 assertEquals(Collections.EMPTY_LIST, errors);
         }
 
-        @ParameterizedTest(name = "Multithread {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        static final String title = "MultiThread {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit " +
+                         "frequency={5} seed={6} config={7}";
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
-        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
-                runFuzzTest("MultithreadS" + steps + "K" + noKeys + "V" + noValues + "CF" + commitFrequency + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+        void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull,
+                                                           int commitFrequency, int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
+                runFuzzTest("MultiThreadS" + steps + "K" + noKeys + "V" + noValues + defaultNull + "CF" + commitFrequency +
+                                 "s" + seed, seed, steps, noKeys, noValues, defaultNull, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
-                return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
-                                new Object[] { 2, 3 }, new Object[] { 10, 100 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
+                                 new Object[]{10, 100}, randomSeedOptions, storeConfigs);
         }
 
-        @ParameterizedTest(name = "Multithread {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = title)
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault,
+                                                          int commitFrequency, int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadTestRunnable.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadTestRunnable.java
index 502c8362..dfe46bae 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadTestRunnable.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadTestRunnable.java
@@ -13,22 +13,23 @@ import java.util.List;
 import java.util.Map;
 import java.util.Random;
 
+import tools.refinery.store.map.Version;
+import tools.refinery.store.map.VersionedMap;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.internal.VersionedMapImpl;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 public class MultiThreadTestRunnable implements Runnable {
-        String scenario;
-        VersionedMapStore<Integer, String> store;
-        int steps;
-        int maxKey;
-        String[] values;
-        int seed;
-        int commitFrequency;
-        List<Throwable> errors = new LinkedList<>();
-        
+        final String scenario;
+        final VersionedMapStore<Integer, String> store;
+        final int steps;
+        final int maxKey;
+        final String[] values;
+        final int seed;
+        final int commitFrequency;
+        final List<Throwable> errors = new LinkedList<>();
+
         public MultiThreadTestRunnable(String scenario, VersionedMapStore<Integer, String> store, int steps,
-                        int maxKey, String[] values, int seed, int commitFrequency) {
+                                                                   int maxKey, String[] values, int seed, int commitFrequency) {
                 super();
                 this.scenario = scenario;
                 this.store = store;
@@ -43,17 +44,25 @@ public class MultiThreadTestRunnable implements Runnable {
                 AssertionError error = new AssertionError(message);
                 errors.add(error);
         }
-        
+
         public List<Throwable> getErrors() {
                 return errors;
         }
-        
+
         @Override
         public void run() {
+                try{
+                        task();
+                } catch(Exception e) {
+                        e.printStackTrace();
+                }
+        }
+
+        private void task() {
                 // 1. build a map with versions
                 Random r = new Random(seed);
-                VersionedMapImpl<Integer, String> versioned = (VersionedMapImpl<Integer, String>) store.createMap();
-                Map<Integer, Long> index2Version = new HashMap<>();
+                VersionedMap<Integer, String> versioned =  store.createMap();
+                Map<Integer, Version> index2Version = new HashMap<>();
 
                 for (int i = 0; i < steps; i++) {
                         int index = i + 1;
@@ -66,15 +75,15 @@ public class MultiThreadTestRunnable implements Runnable {
                                 logAndThrowError(scenario + ":" + index + ": exception happened: " + exception);
                         }
                         if (index % commitFrequency == 0) {
-                                long version = versioned.commit();
+                                Version version = versioned.commit();
                                 index2Version.put(i, version);
                         }
                         MapTestEnvironment.printStatus(scenario, index, steps, "building");
                 }
-                // 2. create a non-versioned 
-                VersionedMapImpl<Integer, String> reference = (VersionedMapImpl<Integer, String>) store.createMap();
+                // 2. create a non-versioned
+                VersionedMap<Integer, String> reference = store.createMap();
                 r = new Random(seed);
-                Random r2 = new Random(seed+1);
+                Random r2 = new Random(seed + 1);
 
                 for (int i = 0; i < steps; i++) {
                         int index = i + 1;
@@ -89,13 +98,16 @@ public class MultiThreadTestRunnable implements Runnable {
                         // go back to an existing state and compare to the reference
                         if (index % (commitFrequency) == 0) {
                                 versioned.restore(index2Version.get(i));
-                                MapTestEnvironment.compareTwoMaps(scenario + ":" + index, reference, versioned,errors);
-                                
+                                MapTestEnvironment.compareTwoMaps(scenario + ":" + index, reference, versioned, null);
+
                                 // go back to a random state (probably created by another thread)
-                                List<Long> states = new ArrayList<>(store.getStates());
+                                List<Version> states = new ArrayList<>(index2Version.values());
+                                //states.sort(Long::compare);
                                 Collections.shuffle(states, r2);
-                                for(Long state : states.subList(0, Math.min(states.size(), 100))) {
+                                for (Version state : states.subList(0, Math.min(states.size(), 100))) {
                                         versioned.restore(state);
+                                        var clean = store.createMap(state);
+                                        MapTestEnvironment.compareTwoMaps(scenario + ":" + index, clean, versioned, null);
                                 }
                                 versioned.restore(index2Version.get(i));
                         }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java
index 32dde0da..fdcd7f9f 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.map.tests.fuzz;
 
 import static org.junit.jupiter.api.Assertions.fail;
+import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
 
 import java.util.Random;
 import java.util.stream.Stream;
@@ -16,21 +17,18 @@ import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-import tools.refinery.store.map.ContinousHashProvider;
-import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.*;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 class MutableFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
-                VersionedMapImpl<Integer, String> sut = (VersionedMapImpl<Integer, String>) store.createMap();
-                MapTestEnvironment<Integer, String> e = new MapTestEnvironment<Integer, String>(sut);
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
+                VersionedMap<Integer, String> sut = store.createMap();
+                MapTestEnvironment<Integer, String> e = new MapTestEnvironment<>(sut);
 
                 Random r = new Random(seed);
 
@@ -38,24 +36,14 @@ class MutableFuzzTest {
         }
 
         private void iterativeRandomPuts(String scenario, int steps, int maxKey, String[] values,
-                        MapTestEnvironment<Integer, String> e, Random r) {
-                int stopAt = -1;
+                                                                         MapTestEnvironment<Integer, String> e, Random r) {
                 for (int i = 0; i < steps; i++) {
                         int index = i + 1;
                         int nextKey = r.nextInt(maxKey);
                         String nextValue = values[r.nextInt(values.length)];
-                        if (index == stopAt) {
-                                System.out.println("issue!");
-                                System.out.println("State before:");
-                                e.printComparison();
-                                e.sut.prettyPrint();
-                                System.out.println("Next: put(" + nextKey + "," + nextValue + ")");
-                        }
+
                         try {
                                 e.put(nextKey, nextValue);
-                                if (index == stopAt) {
-                                        e.sut.prettyPrint();
-                                }
                                 e.checkEquivalence(scenario + ":" + index);
                         } catch (Exception exception) {
                                 exception.printStackTrace();
@@ -65,30 +53,34 @@ class MutableFuzzTest {
                 }
         }
 
-        @ParameterizedTest(name = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} seed={4} evil-hash={5}")
+        final String title = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} seed={5} " +
+                        "config={6}";
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
-        void parametrizedFuzz(int test, int steps, int noKeys, int noValues, int seed, boolean evilHash) {
+        void parametrizedFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull, int seed,
+                                                  VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest(
-                                "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed + "H" + (evilHash ? "Evil" : "Normal"),
-                                seed, steps, noKeys, noValues, evilHash);
+                                "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed,
+                                seed, steps, noKeys, noValues, defaultNull, builder);
         }
 
         static Stream<Arguments> parametrizedFuzz() {
-                return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT },
-                                new Object[] { 3, 32, 32 * 32, 32 * 32 * 32 * 32 }, new Object[] { 2, 3 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
+                                randomSeedOptions, storeConfigs);
         }
-        
-        @ParameterizedTest(name = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} seed={4} evil-hash={5}")
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowFuzz(int test, int steps, int noKeys, int noValues, int seed, boolean evilHash) {
+        void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int seed,
+                                                          VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest(
-                                "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed + "H" + (evilHash ? "Evil" : "Normal"),
-                                seed, steps, noKeys, noValues, evilHash);
+                                "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed,
+                                seed, steps, noKeys, noValues, nullDefault, builder);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableImmutableCompareFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableImmutableCompareFuzzTest.java
index 347c49be..abfb4791 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableImmutableCompareFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableImmutableCompareFuzzTest.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.map.tests.fuzz;
 
 import static org.junit.jupiter.api.Assertions.fail;
+import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
 
 import java.util.Random;
 import java.util.stream.Stream;
@@ -16,22 +17,22 @@ import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-import tools.refinery.store.map.ContinousHashProvider;
+import tools.refinery.store.map.ContinuousHashProvider;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.internal.state.VersionedMapStoreStateImpl;
+import tools.refinery.store.map.internal.state.VersionedMapStateImpl;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 class MutableImmutableCompareFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
-                        boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, int commitFrequency, boolean evilHash) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
+                ContinuousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
-                VersionedMapImpl<Integer, String> immutable = (VersionedMapImpl<Integer, String>) store.createMap();
-                VersionedMapImpl<Integer, String> mutable = (VersionedMapImpl<Integer, String>) store.createMap();
+                VersionedMapStore<Integer, String> store = new VersionedMapStoreStateImpl<>(chp, values[0]);
+                VersionedMapStateImpl<Integer, String> immutable = (VersionedMapStateImpl<Integer, String>) store.createMap();
+                VersionedMapStateImpl<Integer, String> mutable = (VersionedMapStateImpl<Integer, String>) store.createMap();
 
                 Random r = new Random(seed);
 
@@ -39,9 +40,9 @@ class MutableImmutableCompareFuzzTest {
                                 commitFrequency);
         }
 
-        private void iterativeRandomPutsAndCommitsAndCompare(String scenario, VersionedMapImpl<Integer, String> immutable,
-                        VersionedMapImpl<Integer, String> mutable, int steps, int maxKey, String[] values, Random r,
-                        int commitFrequency) {
+        private void iterativeRandomPutsAndCommitsAndCompare(String scenario, VersionedMapStateImpl<Integer, String> immutable,
+                                                                                                                 VersionedMapStateImpl<Integer, String> mutable, int steps, int maxKey, String[] values, Random r,
+                                                                                                                 int commitFrequency) {
                 for (int i = 0; i < steps; i++) {
                         int index = i + 1;
                         int nextKey = r.nextInt(maxKey);
@@ -62,30 +63,31 @@ class MutableImmutableCompareFuzzTest {
                 }
         }
 
-        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " +
+                        "commit frequency={5} seed={6} evil-hash={7}")
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
-        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, boolean evilHash) {
                 runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
-                                noKeys, noValues, commitFrequency, evilHash);
+                                noKeys, noValues, nullDefault, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
-                return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
-                                new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
+                                commitFrequencyOptions, randomSeedOptions, new Object[]{false, true});
         }
 
-        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " +
+                        "commit frequency={5} seed={6} evil-hash={7}")
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, boolean evilHash) {
                 runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
-                                noKeys, noValues, commitFrequency, evilHash);
+                                noKeys, noValues, nullDefault, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java
index f7b9d61e..5c768788 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java
@@ -5,43 +5,43 @@
  */
 package tools.refinery.store.map.tests.fuzz;
 
-import static org.junit.jupiter.api.Assertions.fail;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Random;
-import java.util.stream.Stream;
-
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-
-import tools.refinery.store.map.ContinousHashProvider;
+import tools.refinery.store.map.Version;
+import tools.refinery.store.map.VersionedMap;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.fail;
+import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
+
 class RestoreFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
-                        boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, int commitFrequency,
+                                                         VersionedMapStoreFactoryBuilder<Integer, String> builder) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
 
                 iterativeRandomPutsAndCommitsThenRestore(scenario, store, steps, maxKey, values, seed, commitFrequency);
         }
 
         private void iterativeRandomPutsAndCommitsThenRestore(String scenario, VersionedMapStore<Integer, String> store,
-                        int steps, int maxKey, String[] values, int seed, int commitFrequency) {
+                                                                                                                  int steps, int maxKey, String[] values, int seed, int commitFrequency) {
                 // 1. build a map with versions
                 Random r = new Random(seed);
-                VersionedMapImpl<Integer, String> versioned = (VersionedMapImpl<Integer, String>) store.createMap();
-                Map<Integer, Long> index2Version = new HashMap<>();
+                VersionedMap<Integer, String> versioned = store.createMap();
+                Map<Integer, Version> index2Version = new HashMap<>();
 
                 for (int i = 0; i < steps; i++) {
                         int index = i + 1;
@@ -54,13 +54,13 @@ class RestoreFuzzTest {
                                 fail(scenario + ":" + index + ": exception happened: " + exception);
                         }
                         if (index % commitFrequency == 0) {
-                                long version = versioned.commit();
+                                Version version = versioned.commit();
                                 index2Version.put(i, version);
                         }
                         MapTestEnvironment.printStatus(scenario, index, steps, "building");
                 }
                 // 2. create a non-versioned and
-                VersionedMapImpl<Integer, String> reference = (VersionedMapImpl<Integer, String>) store.createMap();
+                VersionedMap<Integer, String> reference = store.createMap();
                 r = new Random(seed);
 
                 for (int i = 0; i < steps; i++) {
@@ -82,30 +82,32 @@ class RestoreFuzzTest {
 
         }
 
-        @ParameterizedTest(name = "Restore {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        public static final String title = "Commit {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5} " +
+                        "seed={6} config={7}";
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Timeout(value = 10)
         @Tag("smoke")
-        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
-                return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
-                                new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
+                                commitFrequencyOptions, randomSeedOptions, storeConfigs);
         }
 
-        @ParameterizedTest(name = "Restore {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = title)
         @MethodSource
         @Tag("smoke")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SharedStoreFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SharedStoreFuzzTest.java
index 4b4172d0..299c94b1 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SharedStoreFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SharedStoreFuzzTest.java
@@ -18,61 +18,64 @@ import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-import tools.refinery.store.map.ContinousHashProvider;
+import tools.refinery.store.map.ContinuousHashProvider;
+import tools.refinery.store.map.Version;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.internal.state.VersionedMapStoreStateImpl;
+import tools.refinery.store.map.internal.state.VersionedMapStateImpl;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
+import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
+
 class SharedStoreFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
-                        boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, int commitFrequency, boolean evilHash) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
+                ContinuousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
-                List<VersionedMapStore<Integer, String>> stores = VersionedMapStoreImpl.createSharedVersionedMapStores(5, chp, values[0]);
+                List<VersionedMapStore<Integer, String>> stores = VersionedMapStoreStateImpl.createSharedVersionedMapStores(5, chp, values[0]);
 
                 iterativeRandomPutsAndCommitsThenRestore(scenario, stores, steps, maxKey, values, seed, commitFrequency);
         }
 
         private void iterativeRandomPutsAndCommitsThenRestore(String scenario, List<VersionedMapStore<Integer, String>> stores,
-                        int steps, int maxKey, String[] values, int seed, int commitFrequency) {
+                                                                                                                  int steps, int maxKey, String[] values, int seed, int commitFrequency) {
                 // 1. maps with versions
                 Random r = new Random(seed);
-                List<VersionedMapImpl<Integer, String>> versioneds = new LinkedList<>();
-                for(VersionedMapStore<Integer, String> store : stores) {
-                        versioneds.add((VersionedMapImpl<Integer, String>) store.createMap());
+                List<VersionedMapStateImpl<Integer, String>> versioneds = new LinkedList<>();
+                for (VersionedMapStore<Integer, String> store : stores) {
+                        versioneds.add((VersionedMapStateImpl<Integer, String>) store.createMap());
                 }
-                                
-                List<Map<Integer, Long>> index2Version = new LinkedList<>();
-                for(int i = 0; i<stores.size(); i++) {
+
+                List<Map<Integer, Version>> index2Version = new LinkedList<>();
+                for (int i = 0; i < stores.size(); i++) {
                         index2Version.add(new HashMap<>());
                 }
 
                 for (int i = 0; i < steps; i++) {
                         int stepIndex = i + 1;
-                        for (int storeIndex = 0; storeIndex<versioneds.size(); storeIndex++) {
+                        for (int storeIndex = 0; storeIndex < versioneds.size(); storeIndex++) {
                                 int nextKey = r.nextInt(maxKey);
                                 String nextValue = values[r.nextInt(values.length)];
                                 versioneds.get(storeIndex).put(nextKey, nextValue);
                                 if (stepIndex % commitFrequency == 0) {
-                                        long version = versioneds.get(storeIndex).commit();
+                                        Version version = versioneds.get(storeIndex).commit();
                                         index2Version.get(storeIndex).put(i, version);
                                 }
                                 MapTestEnvironment.printStatus(scenario, stepIndex, steps, "building");
-                        }               
+                        }
                 }
                 // 2. create a non-versioned and
-                List<VersionedMapImpl<Integer, String>> reference = new LinkedList<>();
-                for(VersionedMapStore<Integer, String> store : stores) {
-                        reference.add((VersionedMapImpl<Integer, String>) store.createMap());
+                List<VersionedMapStateImpl<Integer, String>> reference = new LinkedList<>();
+                for (VersionedMapStore<Integer, String> store : stores) {
+                        reference.add((VersionedMapStateImpl<Integer, String>) store.createMap());
                 }
                 r = new Random(seed);
 
                 for (int i = 0; i < steps; i++) {
                         int index = i + 1;
-                        for (int storeIndex = 0; storeIndex<versioneds.size(); storeIndex++) {
+                        for (int storeIndex = 0; storeIndex < versioneds.size(); storeIndex++) {
                                 int nextKey = r.nextInt(maxKey);
                                 String nextValue = values[r.nextInt(values.length)];
                                 reference.get(storeIndex).put(nextKey, nextValue);
@@ -81,35 +84,36 @@ class SharedStoreFuzzTest {
                                         MapTestEnvironment.compareTwoMaps(scenario + ":" + index, reference.get(storeIndex), versioneds.get(storeIndex));
                                 }
                         }
-                        MapTestEnvironment.printStatus(scenario, index, steps, "comparison");   
+                        MapTestEnvironment.printStatus(scenario, index, steps, "comparison");
                 }
 
         }
 
-        @ParameterizedTest(name = "Shared Store {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Shared Store {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit " +
+                        "frequency={4} seed={5} evil-hash={6}")
         @MethodSource
         @Timeout(value = 10)
         @Tag("smoke")
-        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, boolean evilHash) {
                 runFuzzTest("SharedS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
-                return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
-                                new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
+                                commitFrequencyOptions, randomSeedOptions, new Object[]{false, true});
         }
 
-        @ParameterizedTest(name = "Shared Store {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Shared Store {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit " +
+                        "frequency={4} seed={5} evil-hash={6}")
         @MethodSource
         @Tag("smoke")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, boolean evilHash) {
                 runFuzzTest("SharedS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SingleThreadFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SingleThreadFuzzTest.java
new file mode 100644
index 00000000..1337cf3a
--- /dev/null
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SingleThreadFuzzTest.java
@@ -0,0 +1,66 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.tests.fuzz;
+
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Timeout;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
+import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
+import tools.refinery.store.map.tests.utils.MapTestEnvironment;
+
+import java.util.stream.Stream;
+
+import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
+
+class SingleThreadFuzzTest {
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault, int commitFrequency, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
+
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
+
+                // initialize runnables
+                MultiThreadTestRunnable runnable = new MultiThreadTestRunnable(scenario, store, steps, maxKey, values, seed, commitFrequency);
+
+                // start threads;
+                runnable.run();
+        }
+
+        static final String title = "SingleThread {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit " +
+                        "frequency={5} seed={6} config={7}";
+
+        @ParameterizedTest(name = title)
+        @MethodSource
+        @Timeout(value = 10)
+        @Tag("fuzz")
+        void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull,
+                                                          int commitFrequency, int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
+                runFuzzTest("SingleThreadS" + steps + "K" + noKeys + "V" + noValues + defaultNull + "CF" + commitFrequency +
+                                "s" + seed, seed, steps, noKeys, noValues, defaultNull, commitFrequency, builder);
+        }
+
+        static Stream<Arguments> parametrizedFastFuzz() {
+                return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
+                                new Object[]{10, 100}, randomSeedOptions, storeConfigs);
+        }
+
+        @ParameterizedTest(name = title)
+        @MethodSource
+        @Tag("fuzz")
+        @Tag("slow")
+        void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault,
+                                                          int commitFrequency, int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
+                runFuzzTest("SingleThreadS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
+                                nullDefault, commitFrequency, builder);
+        }
+
+        static Stream<Arguments> parametrizedSlowFuzz() {
+                return FuzzTestUtils.changeStepCount(RestoreFuzzTest.parametrizedFastFuzz(), 1);
+        }
+}
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java
new file mode 100644
index 00000000..ec04904e
--- /dev/null
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map.tests.fuzz.utils;
+
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
+import tools.refinery.store.map.tests.utils.MapTestEnvironment;
+
+public final class FuzzTestCollections {
+        public static final Object[] stepCounts = {FuzzTestUtils.FAST_STEP_COUNT};
+        public static final Object[] keyCounts = {1 , 32, 32 * 32};
+        public static final Object[] valueCounts = {2, 3};
+        public static final Object[] nullDefaultOptions = {false, true};
+        public static final Object[] commitFrequencyOptions = {1, 10, 100};
+        public static final Object[] randomSeedOptions = {1};
+        public static final Object[] storeConfigs = {
+                        // State based
+                        // Default
+                        VersionedMapStore.<Integer,String>builder()
+                                        .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                        .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE),
+                        // Evil hash code test
+                        VersionedMapStore.<Integer,String>builder()
+                                        .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(true))
+                                        .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE),
+                        // No weak hashmap test
+                        VersionedMapStore.<Integer,String>builder()
+                                        .versionFreeing(false)
+                                        .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                        .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE),
+                        // Copy when committing, do not hurt the work copy, share between saves.
+                        VersionedMapStore.<Integer,String>builder()
+                                        .stateBasedImmutableWhenCommitting(false)
+                                        .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                        .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE),
+                        // Copy when committing, do not hurt the work copy, do not share between states.
+                        VersionedMapStore.<Integer,String>builder()
+                                        .stateBasedImmutableWhenCommitting(false)
+                                        .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                        .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.NO_NODE_CACHE),
+
+                        // Delta based
+                        // Set based transactions
+                        VersionedMapStore.<Integer,String>builder()
+                                        .deltaTransactionStrategy(VersionedMapStoreFactoryBuilder.DeltaTransactionStrategy.SET),
+                        // List based transactions
+                        VersionedMapStore.<Integer,String>builder()
+                                        .deltaTransactionStrategy(VersionedMapStoreFactoryBuilder.DeltaTransactionStrategy.LIST)
+        };
+}
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtils.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtils.java
index a819d348..32675635 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtils.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtils.java
@@ -13,7 +13,7 @@ import java.util.stream.Stream;
 import org.junit.jupiter.params.provider.Arguments;
 
 public final class FuzzTestUtils {
-        public static final int FAST_STEP_COUNT = 500;
+        public static final int FAST_STEP_COUNT = 250;
         public static final int SLOW_STEP_COUNT = 32 * 32 * 32 * 32;
 
         private FuzzTestUtils() {
@@ -56,14 +56,12 @@ public final class FuzzTestUtils {
 
         public static Stream<Arguments> permutationWithSize(Object[]... valueOption) {
                 int size = 1;
-                for (int i = 0; i < valueOption.length; i++) {
-                        size *= valueOption[i].length;
+                for (Object[] objects : valueOption) {
+                        size *= objects.length;
                 }
                 Object[][] newValueOption = new Object[valueOption.length + 1][];
-                newValueOption[0] = new Object[] { size };
-                for (int i = 1; i < newValueOption.length; i++) {
-                        newValueOption[i] = valueOption[i - 1];
-                }
+                newValueOption[0] = new Object[]{size};
+                System.arraycopy(valueOption, 0, newValueOption, 1, newValueOption.length - 1);
                 return permutation(newValueOption);
         }
 }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtilsTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtilsTest.java
index dc621574..951d6336 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtilsTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtilsTest.java
@@ -6,31 +6,36 @@
 package tools.refinery.store.map.tests.fuzz.utils;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.List;
+import java.util.Optional;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.provider.Arguments;
 
 class FuzzTestUtilsTest {
         @Test
         void permutationInternalTest() {
-                List<List<Object>> res = FuzzTestUtils.permutationInternal(0, new Object[] { 1, 2, 3 },
-                                new Object[] { 'a', 'b', 'c' }, new Object[] { "alpha", "beta", "gamma", "delta" });
+                List<List<Object>> res = FuzzTestUtils.permutationInternal(0, new Object[]{1, 2, 3},
+                                new Object[]{'a', 'b', 'c'}, new Object[]{"alpha", "beta", "gamma", "delta"});
                 assertEquals(3 * 3 * 4, res.size());
         }
 
         @Test
         void permutationTest1() {
-                var res = FuzzTestUtils.permutation(new Object[] { 1, 2, 3 }, new Object[] { 'a', 'b', 'c' },
-                                new Object[] { "alpha", "beta", "gamma", "delta" });
+                var res = FuzzTestUtils.permutation(new Object[]{1, 2, 3}, new Object[]{'a', 'b', 'c'},
+                                new Object[]{"alpha", "beta", "gamma", "delta"});
                 assertEquals(3 * 3 * 4, res.count());
         }
 
         @Test
         void permutationTest2() {
-                var res = FuzzTestUtils.permutation(new Object[] { 1, 2, 3 }, new Object[] { 'a', 'b', 'c' },
-                                new Object[] { "alpha", "beta", "gamma", "delta" });
-                var arguments = res.findFirst().get().get();
+                var res = FuzzTestUtils.permutation(new Object[]{1, 2, 3}, new Object[]{'a', 'b', 'c'},
+                                new Object[]{"alpha", "beta", "gamma", "delta"});
+                Optional<Arguments> first = res.findFirst();
+                assertTrue(first.isPresent());
+                var arguments = first.get().get();
                 assertEquals(1, arguments[0]);
                 assertEquals('a', arguments[1]);
                 assertEquals("alpha", arguments[2]);
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/utils/MapTestEnvironment.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/utils/MapTestEnvironment.java
index f861f496..b84df280 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/utils/MapTestEnvironment.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/utils/MapTestEnvironment.java
@@ -6,7 +6,7 @@
 package tools.refinery.store.map.tests.utils;
 
 import tools.refinery.store.map.*;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.internal.state.VersionedMapStateImpl;
 
 import java.util.*;
 import java.util.Map.Entry;
@@ -14,35 +14,35 @@ import java.util.Map.Entry;
 import static org.junit.jupiter.api.Assertions.*;
 
 public class MapTestEnvironment<K, V> {
-        public static String[] prepareValues(int maxValue) {
+        public static String[] prepareValues(int maxValue, boolean nullDefault) {
                 String[] values = new String[maxValue];
-                values[0] = "DEFAULT";
+                if (nullDefault) {
+                        values[0] = null;
+                } else {
+                        values[0] = "DEFAULT";
+                }
+
                 for (int i = 1; i < values.length; i++) {
                         values[i] = "VAL" + i;
                 }
                 return values;
         }
 
-        public static ContinousHashProvider<Integer> prepareHashProvider(final boolean evil) {
+        public static ContinuousHashProvider<Integer> prepareHashProvider(final boolean evil) {
                 // Use maxPrime = 2147483629
 
-                ContinousHashProvider<Integer> chp = new ContinousHashProvider<Integer>() {
-
-                        @Override
-                        public int getHash(Integer key, int index) {
-                                if (evil && index < 15 && index < key / 3) {
-                                        return 7;
-                                }
-                                int result = 1;
-                                final int prime = 31;
+                return (key, index) -> {
+                        if (evil && index < 15 && index < key / 3) {
+                                return 7;
+                        }
+                        int result = 1;
+                        final int prime = 31;
 
-                                result = prime * result + key;
-                                result = prime * result + index;
+                        result = prime * result + key;
+                        result = prime * result + index;
 
-                                return result;
-                        }
+                        return result;
                 };
-                return chp;
         }
 
         public static void printStatus(String scenario, int actual, int max, String stepName) {
@@ -60,29 +60,17 @@ public class MapTestEnvironment<K, V> {
 
         public static <K, V> void compareTwoMaps(String title, VersionedMap<K, V> map1,
                                                                                          VersionedMap<K, V> map2, List<Throwable> errors) {
-                assertEqualsList(map1.getSize(), map2.getSize(), title + ": Sizes not equal", errors);
+                map1.checkIntegrity();
+                map2.checkIntegrity();
 
-                Cursor<K, V> cursor1 = map1.getAll();
-                Cursor<K, V> cursor2 = map2.getAll();
-                while (!cursor1.isTerminated()) {
-                        if (cursor2.isTerminated()) {
-                                fail("cursor 2 terminated before cursor1");
-                        }
-                        assertEqualsList(cursor1.getKey(), cursor2.getKey(), title + ": Keys not equal", errors);
-                        assertEqualsList(cursor2.getValue(), cursor2.getValue(), title + ": Values not equal", errors);
-                        cursor1.move();
-                        cursor2.move();
-                }
-                if (!cursor2.isTerminated()) {
-                        fail("cursor 1 terminated before cursor 2");
-                }
+                assertContentEqualsList(map1, map2, title + ": map1.contentEquals(map2)", errors);
+                assertContentEqualsList(map2, map1, title + ": map2.contentEquals(map1)", errors);
+                assertEqualsList(map1.getSize(), map2.getSize(), title + ": Sizes not equal", errors);
 
                 for (var mode : ContentHashCode.values()) {
                         assertEqualsList(map1.contentHashCode(mode), map2.contentHashCode(mode),
                                         title + ": " + mode + " hashCode check", errors);
                 }
-                assertContentEqualsList(map1, map2, title + ": map1.contentEquals(map2)", errors);
-                assertContentEqualsList(map2, map1, title + ": map2.contentEquals(map1)", errors);
         }
 
         private static void assertEqualsList(Object o1, Object o2, String message, List<Throwable> errors) {
@@ -112,29 +100,35 @@ public class MapTestEnvironment<K, V> {
                 }
         }
 
-        public VersionedMapImpl<K, V> sut;
-        Map<K, V> oracle = new HashMap<K, V>();
+        final private VersionedMap<K, V> sut;
+        final private V defaultValue;
+        Map<K, V> oracle = new HashMap<>();
 
-        public MapTestEnvironment(VersionedMapImpl<K, V> sut) {
+        public MapTestEnvironment(VersionedMap<K, V> sut) {
                 this.sut = sut;
+                this.defaultValue = sut.getDefaultValue();
         }
 
         public void put(K key, V value) {
                 V oldSutValue = sut.put(key, value);
                 V oldOracleValue;
-                if (value != sut.getDefaultValue()) {
+                if (value != defaultValue) {
                         oldOracleValue = oracle.put(key, value);
                 } else {
                         oldOracleValue = oracle.remove(key);
                 }
-                if (oldSutValue == sut.getDefaultValue() && oldOracleValue != null) {
+                if (oldSutValue == defaultValue && oldOracleValue != null) {
                         fail("After put, SUT old nodeId was default, but oracle old value was " + oldOracleValue);
                 }
-                if (oldSutValue != sut.getDefaultValue()) {
+                if (oldSutValue != defaultValue) {
                         assertEquals(oldOracleValue, oldSutValue);
                 }
         }
 
+        public Version commit(){
+                return sut.commit();
+        }
+
         public void checkEquivalence(String title) {
                 // 0. Checking integrity
                 try {
@@ -181,7 +175,7 @@ public class MapTestEnvironment<K, V> {
                 long sutSize = sut.getSize();
                 if (oracleSize != sutSize || oracleSize != elementsInSutEntrySet) {
                         printComparison();
-                        fail(title + ": Non-equivalent size() result: SUT.getSize()=" + sutSize + ", SUT.entryset.size="
+                        fail(title + ": Non-equivalent size() result: SUT.getSize()=" + sutSize + ", SUT.entrySet.size="
                                         + elementsInSutEntrySet + ", Oracle=" + oracleSize + "!");
                 }
         }
@@ -190,15 +184,15 @@ public class MapTestEnvironment<K, V> {
                 K previous = null;
                 Cursor<K, V> cursor = versionedMap.getAll();
                 while (cursor.move()) {
-                        System.out.println(cursor.getKey() + " " + ((VersionedMapImpl<K, V>) versionedMap).getHashProvider().getHash(cursor.getKey(), 0));
+                        //System.out.println(cursor.getKey() + " " + ((VersionedMapImpl<K, V>) versionedMap).getHashProvider()
+                        // .getHash(cursor.getKey(), 0));
                         if (previous != null) {
-                                int comparisonResult = ((VersionedMapImpl<K, V>) versionedMap).getHashProvider().compare(previous,
+                                int comparisonResult = ((VersionedMapStateImpl<K, V>) versionedMap).getHashProvider().compare(previous,
                                                 cursor.getKey());
                                 assertTrue(comparisonResult < 0, scenario + " Cursor order is not incremental!");
                         }
                         previous = cursor.getKey();
                 }
-                System.out.println();
         }
 
         public void printComparison() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/hashtests/HashEfficiencyTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/hashtests/HashEfficiencyTest.java
index 4d4f5e26..5b595da7 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/hashtests/HashEfficiencyTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/model/hashtests/HashEfficiencyTest.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.store.model.hashtests;
+package tools.refinery.store.model.hashTests;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
@@ -14,10 +14,9 @@ import java.util.Random;
 
 import org.junit.jupiter.api.Test;
 
-import tools.refinery.store.map.ContinousHashProvider;
+import tools.refinery.store.map.ContinuousHashProvider;
 import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.model.TupleHashProvider;
-import tools.refinery.store.model.TupleHashProviderBitMagic;
 
 class HashEfficiencyTest {
 
@@ -95,7 +94,7 @@ class HashEfficiencyTest {
                 List<Tuple> p = nRandoms(2, amount, 1);;
                 assertEquals(amount,p.size());
         }
-        private static double calculateHashClashes(List<Tuple> tuples, ContinousHashProvider<Tuple> chp) {
+        private static double calculateHashClashes(List<Tuple> tuples, ContinuousHashProvider<Tuple> chp) {
                 int sumClashes = 0;
 
                 for(int i = 0; i<tuples.size(); i++) {
@@ -108,7 +107,7 @@ class HashEfficiencyTest {
                 }
                 return (sumClashes+0.0) / tuples.size();
         }
-        private static int calculateHashClash(ContinousHashProvider<Tuple> chp, Tuple a, Tuple b) {
+        private static int calculateHashClash(ContinuousHashProvider<Tuple> chp, Tuple a, Tuple b) {
                 if(a.equals(b)) return 0;
                 final int bits = 5;
                 final int segments = Integer.SIZE/bits;
@@ -131,11 +130,9 @@ class HashEfficiencyTest {
         }
         public static void main(String[] args) {
                 List<String> hashNames = new LinkedList<>();
-                List<ContinousHashProvider<Tuple>> hashes = new LinkedList<>();
+                List<ContinuousHashProvider<Tuple>> hashes = new LinkedList<>();
                 hashNames.add("PrimeGroup");
                 hashes.add(new TupleHashProvider());
-                hashNames.add("BitMagic");
-                hashes.add(new TupleHashProviderBitMagic());
 
                 int[] arities = new int[] {2,3,4,5};
                 int[] sizes = new int[] {32*32,32*32*8};
diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
index 56b75804..dc7b776e 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.model.tests;
 
 import org.junit.jupiter.api.Test;
+import tools.refinery.store.map.Version;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.representation.Symbol;
@@ -120,7 +121,7 @@ class ModelTest {
                 assertTrue(model.hasUncommittedChanges());
                 assertEquals(Model.NO_STATE_ID, model.getState());
 
-                long state1 = model.commit();
+                Version state1 = model.commit();
 
                 assertFalse(model.hasUncommittedChanges());
                 assertEquals(state1, model.getState());
@@ -134,7 +135,7 @@ class ModelTest {
                 assertTrue(model.hasUncommittedChanges());
                 assertEquals(state1, model.getState());
 
-                long state2 = model.commit();
+                Version state2 = model.commit();
 
                 assertFalse(model.hasUncommittedChanges());
                 assertEquals(state2, model.getState());
diff --git a/subprojects/store/src/test/java/tools/refinery/store/statecoding/EquivalenceTest.java b/subprojects/store/src/test/java/tools/refinery/store/statecoding/EquivalenceTest.java
new file mode 100644
index 00000000..3c35849e
--- /dev/null
+++ b/subprojects/store/src/test/java/tools/refinery/store/statecoding/EquivalenceTest.java
@@ -0,0 +1,217 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.map.Version;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.statecoding.neighbourhood.ObjectCodeImpl;
+import tools.refinery.store.tuple.Tuple;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class EquivalenceTest {
+        Symbol<Boolean> person = new Symbol<>("Person", 1, Boolean.class, false);
+        Symbol<Integer> age = new Symbol<>("age", 1, Integer.class, null);
+        Symbol<Boolean> friend = new Symbol<>("friend", 2, Boolean.class, false);
+        Symbol<Boolean> parents = new Symbol<>("parents", 3, Boolean.class, false);
+        Symbol<Integer> population = new Symbol<>("population", 0, Integer.class, 0);
+
+        private ModelStore createStore() {
+                return ModelStore.builder()
+                                .symbols(person, age, friend, parents, population)
+                                .with(StateCoderAdapter.builder())
+                                .build();
+        }
+
+        @Test
+        void emptyModelCode0() {
+                ModelStore store = createStore();
+                var stateCoder = store.getAdapter(StateCoderStoreAdapter.class);
+                Model model = createStore().createEmptyModel();
+                Version v1 = model.commit();
+                Version v2 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.ISOMORPHIC, stateCoder.checkEquivalence(v1, v2));
+
+                var personI = model.getInterpretation(person);
+                var friendI = model.getInterpretation(friend);
+
+                personI.put(Tuple.of(1), true);
+                personI.put(Tuple.of(2), true);
+                friendI.put(Tuple.of(1, 2), true);
+
+                Version v3 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.DIFFERENT, stateCoder.checkEquivalence(v1, v3));
+        }
+
+        @Test
+        void nullRelationTest() {
+                ModelStore store = createStore();
+                var stateCoder = store.getAdapter(StateCoderStoreAdapter.class);
+                Model model = createStore().createEmptyModel();
+
+                var populationI = model.getInterpretation(population);
+
+                Version v1 = model.commit();
+
+                populationI.put(Tuple.of(), 1);
+                Version v2 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.DIFFERENT, stateCoder.checkEquivalence(v1, v2));
+
+                populationI.put(Tuple.of(), 2);
+                Version v3 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.DIFFERENT, stateCoder.checkEquivalence(v2, v3));
+        }
+
+        @Test
+        void unaryBooleanTest() {
+                ModelStore store = createStore();
+                var stateCoder = store.getAdapter(StateCoderStoreAdapter.class);
+                Model model = createStore().createEmptyModel();
+
+                var personI = model.getInterpretation(person);
+
+                Version v1 = model.commit();
+
+                personI.put(Tuple.of(1), true);
+                Version v2 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.DIFFERENT, stateCoder.checkEquivalence(v1, v2));
+
+                personI.put(Tuple.of(2), true);
+                Version v3 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.DIFFERENT, stateCoder.checkEquivalence(v2, v3));
+
+                personI.put(Tuple.of(1), false);
+                Version v4 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.ISOMORPHIC, stateCoder.checkEquivalence(v2, v4));
+        }
+
+        @Test
+        void unaryIntTest() {
+                ModelStore store = createStore();
+                var stateCoder = store.getAdapter(StateCoderStoreAdapter.class);
+                Model model = createStore().createEmptyModel();
+
+                var ageI = model.getInterpretation(age);
+
+                ageI.put(Tuple.of(1), 3);
+                Version v1 = model.commit();
+
+                ageI.put(Tuple.of(1), 4);
+                Version v2 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.DIFFERENT, stateCoder.checkEquivalence(v1, v2));
+
+                ageI.put(Tuple.of(2), 4);
+                Version v3 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.DIFFERENT, stateCoder.checkEquivalence(v2, v3));
+
+                ageI.put(Tuple.of(1), null);
+                Version v4 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.ISOMORPHIC, stateCoder.checkEquivalence(v2, v4));
+        }
+
+        @Test
+        void binaryTest() {
+                ModelStore store = createStore();
+                var stateCoder = store.getAdapter(StateCoderStoreAdapter.class);
+                Model model = createStore().createEmptyModel();
+
+                var friendI = model.getInterpretation(friend);
+
+                Version v1 = model.commit();
+
+                friendI.put(Tuple.of(1, 2), true);
+                Version v2 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.DIFFERENT, stateCoder.checkEquivalence(v1, v2));
+
+                friendI.put(Tuple.of(2, 1), true);
+                Version v3 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.DIFFERENT, stateCoder.checkEquivalence(v2, v3));
+
+                friendI.put(Tuple.of(1, 2), false);
+                Version v4 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.ISOMORPHIC, stateCoder.checkEquivalence(v2, v4));
+        }
+
+        @Test
+        void NaryTest() {
+                ModelStore store = createStore();
+                var stateCoder = store.getAdapter(StateCoderStoreAdapter.class);
+                Model model = createStore().createEmptyModel();
+
+                var parentsI = model.getInterpretation(parents);
+
+                Version v1 = model.commit();
+
+                parentsI.put(Tuple.of(3, 1, 2), true);
+                Version v2 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.DIFFERENT, stateCoder.checkEquivalence(v1, v2));
+
+                parentsI.put(Tuple.of(4, 1, 2), true);
+                Version v3 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.DIFFERENT, stateCoder.checkEquivalence(v2, v3));
+
+                parentsI.put(Tuple.of(3, 1, 2), false);
+                Version v4 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.ISOMORPHIC, stateCoder.checkEquivalence(v2, v4));
+        }
+
+        @Test
+        void largeUnknownTest() {
+                final int limit = 100;
+
+                StateCodeCalculator calculator = () -> {
+                        var code = new ObjectCodeImpl();
+                        for (int i = 0; i < limit; i++) {
+                                code.set(i, 1);
+                        }
+                        return new StateCoderResult(1, code);
+                };
+
+                ModelStore store = ModelStore.builder()
+                                .symbols(person, age, friend, parents, population)
+                                .with(StateCoderAdapter.builder()
+                                                .stateCodeCalculatorFactory((p1, p2) -> calculator))
+                                .build();
+
+                var stateCoder = store.getAdapter(StateCoderStoreAdapter.class);
+                Model model = createStore().createEmptyModel();
+
+                var personI = model.getInterpretation(person);
+                var friendI = model.getInterpretation(friend);
+
+                for (int i = 0; i < limit; i++) {
+                        personI.put(Tuple.of(i), true);
+                }
+
+                friendI.put(Tuple.of(11,12),true);
+                var v1 = model.commit();
+
+                friendI.put(Tuple.of(11,12),false);
+                friendI.put(Tuple.of(21,22),false);
+                var v2 = model.commit();
+
+                assertEquals(StateEquivalenceChecker.EquivalenceResult.UNKNOWN, stateCoder.checkEquivalence(v1,v2));
+        }
+}
diff --git a/subprojects/store/src/test/java/tools/refinery/store/statecoding/ExperimentalSetupTest.java b/subprojects/store/src/test/java/tools/refinery/store/statecoding/ExperimentalSetupTest.java
new file mode 100644
index 00000000..f5ffc18d
--- /dev/null
+++ b/subprojects/store/src/test/java/tools/refinery/store/statecoding/ExperimentalSetupTest.java
@@ -0,0 +1,199 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+import org.eclipse.collections.api.factory.primitive.IntObjectMaps;
+import org.eclipse.collections.api.map.primitive.MutableIntObjectMap;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import tools.refinery.store.map.Version;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ExperimentalSetupTest {
+        static class ExperimentalSetupResult {
+                int versions = 0;
+                int different = 0;
+                int isomorphic = 0;
+                int unknown = 0;
+
+                double failureRatio() {
+                        return (different + 0.0) / versions;
+                }
+
+                @Override
+                public String toString() {
+                        return "ExperimentalSetupResult{" +
+                                        "versions=" + versions +
+                                        ", different=" + different +
+                                        ", isomorphic=" + isomorphic +
+                                        ", unknown=" + unknown +
+                                        ", ratio= " + failureRatio() +
+                                        '}';
+                }
+        }
+
+        static int MAX = 100000;
+
+        public static ExperimentalSetupResult generate(int size, boolean permuteTypes) {
+                Symbol<Boolean> person = new Symbol<>("Person", 1, Boolean.class, false);
+                Symbol<Boolean> friend = new Symbol<>("friend", 2, Boolean.class, false);
+
+                var store = ModelStore.builder()
+                                .symbols(person, friend)
+                                .with(StateCoderAdapter
+                                                .builder())
+                                .build();
+
+                Set<Version> versions = new HashSet<>();
+                MutableIntObjectMap<List<Version>> codes = IntObjectMaps.mutable.empty();
+
+                var empty = store.createEmptyModel();
+                if (!permuteTypes) {
+                        for (int i = 0; i < size; i++) {
+                                empty.getInterpretation(person).put(Tuple.of(i), true);
+                        }
+                }
+
+                var emptyVersion = empty.commit();
+                versions.add(emptyVersion);
+                var emptyCode = empty.getAdapter(StateCoderAdapter.class).calculateModelCode();
+                List<Version> emptyList = new ArrayList<>();
+                emptyList.add(emptyVersion);
+                codes.put(emptyCode, emptyList);
+
+                var storeAdapter = store.getAdapter(StateCoderStoreAdapter.class);
+                var result = new ExperimentalSetupResult();
+
+                int steps = 0;
+
+                if (permuteTypes) {
+                        for (int i = 0; i < size; i++) {
+                                var previousVersions = new HashSet<>(versions);
+                                for (var version : previousVersions) {
+                                        var model = store.createModelForState(version);
+                                        model.getInterpretation(person).put(Tuple.of(i), true);
+
+                                        saveAsNewVersion(versions, codes, storeAdapter, result, model);
+
+                                        logProgress(steps++);
+                                        if (steps > MAX) {
+                                                result.versions = versions.size();
+                                                return result;
+                                        }
+                                }
+                        }
+                }
+
+                for (int i = 0; i < size; i++) {
+                        for (int j = 0; j < size; j++) {
+                                var previousVersions = new HashSet<>(versions);
+                                for (var version : previousVersions) {
+
+                                        var model = store.createModelForState(version);
+                                        model.getInterpretation(friend).put(Tuple.of(i, j), true);
+
+                                        saveAsNewVersion(versions, codes, storeAdapter, result, model);
+
+                                        logProgress(steps++);
+                                        if (steps > MAX) {
+                                                result.versions = versions.size();
+                                                return result;
+                                        }
+                                }
+                        }
+                }
+
+                result.versions = versions.size();
+                return result;
+        }
+
+        private static void saveAsNewVersion(Set<Version> versions, MutableIntObjectMap<List<Version>> codes,
+                                                                                 StateCoderStoreAdapter storeAdapter, ExperimentalSetupResult result,
+                                                                                 Model model) {
+                Version version1 = model.commit();
+
+                var stateCode = model.getAdapter(StateCoderAdapter.class).calculateStateCode();
+                int code = stateCode.modelCode();
+                if (codes.containsKey(code)) {
+                        Version similar = codes.get(code).get(0);
+
+                        var outcome = storeAdapter.checkEquivalence(version1, similar);
+                        if (outcome == StateEquivalenceChecker.EquivalenceResult.DIFFERENT) {
+                                result.different++;
+                        } else if (outcome == StateEquivalenceChecker.EquivalenceResult.UNKNOWN) {
+                                result.unknown++;
+                        } else {
+                                result.isomorphic++;
+                        }
+                } else {
+                        versions.add(version1);
+
+                        List<Version> newList = new ArrayList<>();
+                        newList.add(version1);
+                        codes.put(code, newList);
+                }
+        }
+
+        private static void logProgress(int steps) {
+                if (steps % 10000 == 0) {
+                        System.out.println("Steps: " + steps + " / " + MAX);
+                }
+        }
+
+        static final double limit = 0.01;
+
+        @Test
+        void test0() {
+                assertEquals(1, generate(0, true).versions);
+        }
+
+        @ParameterizedTest
+        @ValueSource(ints = {1, 2, 3, 4})
+        void testForSmallUntypedModels(int size) {
+                var res = generate(size, false);
+                System.out.println(res);
+                assertTrue(res.failureRatio() < limit);
+        }
+
+        @ParameterizedTest
+        @ValueSource(ints = {1, 2, 3})
+        void testForSmallTypedModels(int size) {
+                var res = generate(size, true);
+                System.out.println(res);
+                assertTrue(res.failureRatio() < limit);
+        }
+
+        @Test
+        @Tag("fuzz")
+        @Tag("slow")
+        void testForLargeTypedModels() {
+                var res = generate(10, true);
+                System.out.println(res);
+                assertTrue(res.failureRatio() < limit);
+        }
+
+        @Test
+        @Tag("fuzz")
+        @Tag("slow")
+        void testForLargeUntypedModels() {
+                var res = generate(10, false);
+                System.out.println(res);
+                assertTrue(res.failureRatio() < limit);
+        }
+}
diff --git a/subprojects/store/src/test/java/tools/refinery/store/statecoding/StateCoderBuildTest.java b/subprojects/store/src/test/java/tools/refinery/store/statecoding/StateCoderBuildTest.java
new file mode 100644
index 00000000..0b738005
--- /dev/null
+++ b/subprojects/store/src/test/java/tools/refinery/store/statecoding/StateCoderBuildTest.java
@@ -0,0 +1,171 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class StateCoderBuildTest {
+        Symbol<Boolean> person = new Symbol<>("Person", 1, Boolean.class, false);
+        Symbol<Integer> age = new Symbol<>("age", 1, Integer.class, null);
+        Symbol<Boolean> friend = new Symbol<>("friend", 2, Boolean.class, false);
+
+        @Test
+        void simpleStateCoderBuildTest() {
+                var store = ModelStore.builder()
+                                .symbols(person, age, friend)
+                                .with(StateCoderAdapter.builder())
+                                .build();
+
+                var model = store.createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+                assertNotNull(stateCoder);
+
+                var personI = model.getInterpretation(person);
+                var friendI = model.getInterpretation(friend);
+                var ageI = model.getInterpretation(age);
+
+                fill(personI, friendI, ageI);
+
+                stateCoder.calculateStateCode();
+        }
+
+        @Test
+        void excludeTest() {
+                var store = ModelStore.builder()
+                                .symbols(person, age, friend)
+                                .with(StateCoderAdapter.builder()
+                                                .exclude(person)
+                                                .exclude(age))
+                                .build();
+
+                var model = store.createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+                assertNotNull(stateCoder);
+
+                var personI = model.getInterpretation(person);
+                var friendI = model.getInterpretation(friend);
+                var ageI = model.getInterpretation(age);
+                fill(personI, friendI, ageI);
+
+                int code = stateCoder.calculateStateCode().modelCode();
+
+                ageI.put(Tuple.of(1), 3);
+                assertEquals(code, stateCoder.calculateStateCode().modelCode());
+
+                ageI.put(Tuple.of(1), null);
+                assertEquals(code, stateCoder.calculateStateCode().modelCode());
+
+                personI.put(Tuple.of(2), false);
+                assertEquals(code, stateCoder.calculateStateCode().modelCode());
+        }
+
+        @Test
+        void notIndividualTest() {
+                var store = ModelStore.builder()
+                                .symbols(friend)
+                                .with(StateCoderAdapter.builder())
+                                .build();
+
+                var model = store.createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+
+                var friendI = model.getInterpretation(friend);
+
+                friendI.put(Tuple.of(1, 2), true);
+                int code1 = stateCoder.calculateModelCode();
+
+                friendI.put(Tuple.of(1, 2), false);
+                friendI.put(Tuple.of(2, 1), true);
+                int code2 = stateCoder.calculateModelCode();
+
+                assertEquals(code1, code2);
+        }
+
+        @Test
+        void individualTest() {
+                var store = ModelStore.builder()
+                                .symbols(friend)
+                                .with(StateCoderAdapter.builder()
+                                                .individual(Tuple.of(1)))
+                                .build();
+
+                var model = store.createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+
+                var friendI = model.getInterpretation(friend);
+
+                friendI.put(Tuple.of(1, 2), true);
+                int code1 = stateCoder.calculateModelCode();
+
+                friendI.put(Tuple.of(1, 2), false);
+                friendI.put(Tuple.of(2, 1), true);
+                int code2 = stateCoder.calculateModelCode();
+
+                assertNotEquals(code1, code2);
+        }
+
+        @Test
+        void customStateCoderTest() {
+                final boolean[] called = new boolean[]{false};
+                StateCodeCalculator mock = () -> {
+                        called[0] = true;
+                        return null;
+                };
+
+                var store = ModelStore.builder()
+                                .symbols(friend)
+                                .with(StateCoderAdapter.builder()
+                                                .stateCodeCalculatorFactory((interpretations, individuals) -> mock))
+                                .build();
+
+                var model = store.createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+
+                stateCoder.calculateStateCode();
+
+                assertTrue(called[0]);
+        }
+
+        @Test
+        void customEquivalenceCheckerTest() {
+                final boolean[] called = new boolean[]{false};
+                StateEquivalenceChecker mock = (p1, p2, p3, p4, p5) -> {
+                        called[0] = true;
+                        return StateEquivalenceChecker.EquivalenceResult.UNKNOWN;
+                };
+
+                var store = ModelStore.builder()
+                                .symbols(friend)
+                                .with(StateCoderAdapter.builder()
+                                                .stateEquivalenceChecker(mock))
+                                .build();
+
+                var model = store.createEmptyModel();
+                var v1 = model.commit();
+                var v2 = model.commit();
+
+                store.getAdapter(StateCoderStoreAdapter.class).checkEquivalence(v1, v2);
+
+                assertTrue(called[0]);
+        }
+
+
+        private static void fill(Interpretation<Boolean> personI, Interpretation<Boolean> friendI, Interpretation<Integer> ageI) {
+                personI.put(Tuple.of(1), true);
+                personI.put(Tuple.of(2), true);
+
+                ageI.put(Tuple.of(1), 5);
+                ageI.put(Tuple.of(2), 4);
+
+                friendI.put(Tuple.of(1, 2), true);
+        }
+}
diff --git a/subprojects/store/src/test/java/tools/refinery/store/statecoding/StateCoderUnitTest.java b/subprojects/store/src/test/java/tools/refinery/store/statecoding/StateCoderUnitTest.java
new file mode 100644
index 00000000..d94df841
--- /dev/null
+++ b/subprojects/store/src/test/java/tools/refinery/store/statecoding/StateCoderUnitTest.java
@@ -0,0 +1,195 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Objects;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class StateCoderUnitTest {
+        Symbol<Boolean> person = new Symbol<>("Person", 1, Boolean.class, false);
+        Symbol<Integer> age = new Symbol<>("age", 1, Integer.class, null);
+        Symbol<Boolean> friend = new Symbol<>("friend", 2, Boolean.class, false);
+        Symbol<Boolean> parents = new Symbol<>("parents", 3, Boolean.class, false);
+        Symbol<Integer> population = new Symbol<>("population", 0, Integer.class, 0);
+
+        private Model createEmptyModel() {
+                var store = ModelStore.builder()
+                                .symbols(person, age, friend, parents, population)
+                                .with(StateCoderAdapter.builder())
+                                .build();
+
+                return store.createEmptyModel();
+        }
+
+        @Test
+        void emptyModelCode0() {
+                Model model = createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+
+                assertEquals(0, stateCoder.calculateModelCode());
+
+                var personI = model.getInterpretation(person);
+                var friendI = model.getInterpretation(friend);
+
+                personI.put(Tuple.of(1), true);
+                personI.put(Tuple.of(2), true);
+                friendI.put(Tuple.of(1, 2), true);
+
+                assertNotEquals(0, stateCoder.calculateModelCode());
+        }
+
+        @Test
+        void emptyObjectCode0() {
+                Model model = createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+
+                var personI = model.getInterpretation(person);
+                var friendI = model.getInterpretation(friend);
+
+                assertEquals(0, stateCoder.calculateObjectCode().get(1));
+                assertEquals(0, stateCoder.calculateObjectCode().get(17));
+
+                personI.put(Tuple.of(1), true);
+                personI.put(Tuple.of(2), true);
+                friendI.put(Tuple.of(1, 2), true);
+
+                assertNotEquals(0, stateCoder.calculateObjectCode().get(1));
+                assertEquals(0, stateCoder.calculateObjectCode().get(17));
+        }
+
+        @Test
+        void nullRelationTest() {
+                Model model = createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+
+                var populationI = model.getInterpretation(population);
+
+                final int hashOf0 = Objects.hashCode(0);
+
+                assertEquals(hashOf0, stateCoder.calculateModelCode());
+
+                populationI.put(Tuple.of(), 1);
+                int code1 = stateCoder.calculateModelCode();
+
+                assertNotEquals(hashOf0, stateCoder.calculateModelCode());
+
+                populationI.put(Tuple.of(), 2);
+                int code2 = stateCoder.calculateModelCode();
+
+                assertNotEquals(code1, code2);
+
+                populationI.put(Tuple.of(), 1);
+                assertEquals(code1, stateCoder.calculateModelCode());
+        }
+
+        @Test
+        void unaryBooleanTest() {
+                Model model = createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+
+                var personI = model.getInterpretation(person);
+
+                assertEquals(0, stateCoder.calculateModelCode());
+
+                personI.put(Tuple.of(1), true);
+                int code1 = stateCoder.calculateModelCode();
+
+                assertNotEquals(0, stateCoder.calculateModelCode());
+
+                personI.put(Tuple.of(2), true);
+                int code2 = stateCoder.calculateModelCode();
+
+                assertNotEquals(code1, code2);
+
+                personI.put(Tuple.of(1), false);
+                assertEquals(code1, stateCoder.calculateModelCode());
+        }
+
+        @Test
+        void unaryIntTest() {
+                Model model = createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+
+                var ageI = model.getInterpretation(age);
+
+                assertEquals(0, stateCoder.calculateModelCode());
+
+                ageI.put(Tuple.of(1), 4);
+                int code0 = stateCoder.calculateModelCode();
+
+                assertNotEquals(0, code0);
+
+                ageI.put(Tuple.of(1), 5);
+                int code1 = stateCoder.calculateModelCode();
+
+                assertNotEquals(code0, code1);
+
+                ageI.put(Tuple.of(2), 5);
+                int code2 = stateCoder.calculateModelCode();
+
+                assertNotEquals(code1, code2);
+
+                ageI.put(Tuple.of(1), null);
+                assertEquals(code1, stateCoder.calculateModelCode());
+        }
+
+        @Test
+        void binaryTest() {
+                Model model = createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+
+                var friendI = model.getInterpretation(friend);
+
+                assertEquals(0, stateCoder.calculateModelCode());
+
+                friendI.put(Tuple.of(1, 2), true);
+                int code1 = stateCoder.calculateModelCode();
+
+                assertNotEquals(0, code1);
+
+                friendI.put(Tuple.of(2, 1), true);
+                int code2 = stateCoder.calculateModelCode();
+
+                assertNotEquals(code1, code2);
+
+                friendI.put(Tuple.of(1, 2), false);
+                int code3 = stateCoder.calculateModelCode();
+
+                assertEquals(code1, code3);
+        }
+
+        @Test
+        void NaryTest() {
+                Model model = createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+
+                var parentsI = model.getInterpretation(parents);
+
+                assertEquals(0, stateCoder.calculateModelCode());
+
+                parentsI.put(Tuple.of(3, 1, 2), true);
+                int code1 = stateCoder.calculateModelCode();
+
+                assertNotEquals(0, code1);
+
+                parentsI.put(Tuple.of(4, 1, 2), true);
+                int code2 = stateCoder.calculateModelCode();
+
+                assertNotEquals(code1, code2);
+
+                parentsI.put(Tuple.of(3, 1, 2), false);
+                int code3 = stateCoder.calculateModelCode();
+
+                assertEquals(code1, code3);
+        }
+}
diff --git a/subprojects/visualization/build.gradle.kts b/subprojects/visualization/build.gradle.kts
new file mode 100644
index 00000000..abad0491
--- /dev/null
+++ b/subprojects/visualization/build.gradle.kts
@@ -0,0 +1,13 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+plugins {
+        id("tools.refinery.gradle.java-library")
+}
+
+dependencies {
+        api(project(":refinery-store-query"))
+}
diff --git a/subprojects/visualization/src/main/java/tools/refinery/visualization/ModelVisualizerAdapter.java b/subprojects/visualization/src/main/java/tools/refinery/visualization/ModelVisualizerAdapter.java
new file mode 100644
index 00000000..ae87d8ac
--- /dev/null
+++ b/subprojects/visualization/src/main/java/tools/refinery/visualization/ModelVisualizerAdapter.java
@@ -0,0 +1,32 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.visualization;
+
+import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.map.Version;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.visualization.internal.ModelVisualizerBuilderImpl;
+
+import java.util.Collection;
+
+public interface ModelVisualizerAdapter extends ModelAdapter {
+
+        ModelVisualizerStoreAdapter getStoreAdapter();
+        static ModelVisualizerBuilder builder() {
+                return new ModelVisualizerBuilderImpl();
+        }
+
+        public void addTransition(Version from, Version to, String action);
+
+
+        public void addTransition(Version from, Version to, String action, Tuple  activation);
+        public void addState(Version state);
+        public void addState(Version state, Collection<Double> fitness);
+        public void addState(Version state, String label);
+        public void addSolution(Version state);
+        public void visualize();
+
+}
diff --git a/subprojects/visualization/src/main/java/tools/refinery/visualization/ModelVisualizerBuilder.java b/subprojects/visualization/src/main/java/tools/refinery/visualization/ModelVisualizerBuilder.java
new file mode 100644
index 00000000..592f5fcf
--- /dev/null
+++ b/subprojects/visualization/src/main/java/tools/refinery/visualization/ModelVisualizerBuilder.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.visualization;
+
+import tools.refinery.store.adapter.ModelAdapterBuilder;
+import tools.refinery.visualization.internal.FileFormat;
+
+public interface ModelVisualizerBuilder extends ModelAdapterBuilder {
+        ModelVisualizerBuilder withOutputpath(String outputpath);
+        ModelVisualizerBuilder withFormat(FileFormat format);
+        ModelVisualizerBuilder saveDesignSpace();
+        ModelVisualizerBuilder saveStates();
+}
diff --git a/subprojects/visualization/src/main/java/tools/refinery/visualization/ModelVisualizerStoreAdapter.java b/subprojects/visualization/src/main/java/tools/refinery/visualization/ModelVisualizerStoreAdapter.java
new file mode 100644
index 00000000..46663b2a
--- /dev/null
+++ b/subprojects/visualization/src/main/java/tools/refinery/visualization/ModelVisualizerStoreAdapter.java
@@ -0,0 +1,22 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.visualization;
+
+import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.visualization.internal.FileFormat;
+
+import java.util.Set;
+
+public interface ModelVisualizerStoreAdapter extends ModelStoreAdapter {
+
+        String getOutputPath();
+
+        boolean isRenderDesignSpace();
+
+        boolean isRenderStates();
+
+        Set<FileFormat> getFormats();
+}
diff --git a/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/FileFormat.java b/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/FileFormat.java
new file mode 100644
index 00000000..c5dffeb2
--- /dev/null
+++ b/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/FileFormat.java
@@ -0,0 +1,26 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.visualization.internal;
+
+public enum FileFormat {
+        BMP("bmp"),
+        DOT("dot"),
+        JPEG("jpg"),
+        PDF("pdf"),
+        PLAIN("plain"),
+        PNG("png"),
+        SVG("svg");
+
+        private final String format;
+
+        FileFormat(String format) {
+                this.format = format;
+        }
+
+        public String getFormat() {
+                return format;
+        }
+}
diff --git a/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/ModelVisualizeStoreAdapterImpl.java b/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/ModelVisualizeStoreAdapterImpl.java
new file mode 100644
index 00000000..04be22d6
--- /dev/null
+++ b/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/ModelVisualizeStoreAdapterImpl.java
@@ -0,0 +1,60 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.visualization.internal;
+
+import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.visualization.ModelVisualizerStoreAdapter;
+
+import java.util.Set;
+
+public class ModelVisualizeStoreAdapterImpl implements ModelVisualizerStoreAdapter {
+        private final ModelStore store;
+        private final String outputPath;
+        private final boolean renderDesignSpace;
+        private final boolean renderStates;
+        private final Set<FileFormat> formats;
+
+        public ModelVisualizeStoreAdapterImpl(ModelStore store, String outputPath, Set<FileFormat> formats,
+                                                                                  boolean renderDesignSpace, boolean renderStates) {
+                this.store = store;
+                this.outputPath = outputPath;
+                this.formats = formats;
+                this.renderDesignSpace = renderDesignSpace;
+                this.renderStates = renderStates;
+        }
+
+        @Override
+        public ModelStore getStore() {
+                return store;
+        }
+
+        @Override
+        public ModelAdapter createModelAdapter(Model model) {
+                return new ModelVisualizerAdapterImpl(model, this);
+        }
+
+        @Override
+        public String getOutputPath() {
+                return outputPath;
+        }
+
+        @Override
+        public boolean isRenderDesignSpace() {
+                return renderDesignSpace;
+        }
+
+        @Override
+        public boolean isRenderStates() {
+                return renderStates;
+        }
+
+        @Override
+        public Set<FileFormat> getFormats() {
+                return formats;
+        }
+}
diff --git a/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/ModelVisualizerAdapterImpl.java b/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/ModelVisualizerAdapterImpl.java
new file mode 100644
index 00000000..531969b4
--- /dev/null
+++ b/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/ModelVisualizerAdapterImpl.java
@@ -0,0 +1,387 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.visualization.internal;
+
+import tools.refinery.store.map.Version;
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.visualization.ModelVisualizerAdapter;
+import tools.refinery.visualization.ModelVisualizerStoreAdapter;
+
+import java.io.*;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class ModelVisualizerAdapterImpl implements ModelVisualizerAdapter {
+        private final Model model;
+        private final ModelVisualizerStoreAdapter storeAdapter;
+        private final Map<AnySymbol, Interpretation<?>> allInterpretations;
+        private final StringBuilder designSpaceBuilder = new StringBuilder();
+        private final Map<Version, Integer> states = new HashMap<>();
+        private int transitionCounter = 0;
+        private Integer numberOfStates = 0;
+        private final String outputPath;
+        private final Set<FileFormat> formats;
+        private final boolean renderDesignSpace;
+        private final boolean renderStates;
+
+        private static final Map<Object, String> truthValueToDot = Map.of(
+                        TruthValue.TRUE, "1",
+                        TruthValue.FALSE, "0",
+                        TruthValue.UNKNOWN, "½",
+                        TruthValue.ERROR, "E",
+                        true, "1",
+                        false, "0"
+        );
+
+        public ModelVisualizerAdapterImpl(Model model, ModelVisualizerStoreAdapter storeAdapter) {
+                this.model = model;
+                this.storeAdapter = storeAdapter;
+                this.outputPath = storeAdapter.getOutputPath();
+                this.formats = storeAdapter.getFormats();
+                if (formats.isEmpty()) {
+                        formats.add(FileFormat.SVG);
+                }
+                this.renderDesignSpace = storeAdapter.isRenderDesignSpace();
+                this.renderStates = storeAdapter.isRenderStates();
+
+                this.allInterpretations = new HashMap<>();
+                for (var symbol : storeAdapter.getStore().getSymbols()) {
+                        var arity = symbol.arity();
+                        if (arity < 1 || arity > 2) {
+                                continue;
+                        }
+                        var interpretation = (Interpretation<?>) model.getInterpretation(symbol);
+                        allInterpretations.put(symbol, interpretation);
+                }
+                designSpaceBuilder.append("digraph designSpace {\n");
+                designSpaceBuilder.append("""
+                                nodesep=0
+                                ranksep=5
+                                node[
+                                \tstyle=filled
+                                \tfillcolor=white
+                                ]
+                                """);
+        }
+
+        @Override
+        public Model getModel() {
+                return model;
+        }
+
+        @Override
+        public ModelVisualizerStoreAdapter getStoreAdapter() {
+                return storeAdapter;
+        }
+
+        private String createDotForCurrentModelState() {
+
+                var unaryTupleToInterpretationsMap = new HashMap<Tuple, LinkedHashSet<Interpretation<?>>>();
+
+                var sb = new StringBuilder();
+
+                sb.append("digraph model {\n");
+                sb.append("""
+                                node [
+                                \tstyle="filled, rounded"
+                                \tshape=plain
+                                \tpencolor="#00000088"
+                                \tfontname="Helvetica"
+                                ]
+                                """);
+                sb.append("""
+                                edge [
+                                \tlabeldistance=3
+                                \tfontname="Helvetica"
+                                ]
+                                """);
+
+                for (var entry : allInterpretations.entrySet()) {
+                        var key = entry.getKey();
+                        var arity = key.arity();
+                        var cursor = entry.getValue().getAll();
+                        if (arity == 1) {
+                                while (cursor.move()) {
+                                        unaryTupleToInterpretationsMap.computeIfAbsent(cursor.getKey(), k -> new LinkedHashSet<>())
+                                                        .add(entry.getValue());
+                                }
+                        } else if (arity == 2) {
+                                while (cursor.move()) {
+                                        var tuple = cursor.getKey();
+                                        for (var i = 0; i < tuple.getSize(); i++) {
+                                                var id = tuple.get(i);
+                                                unaryTupleToInterpretationsMap.computeIfAbsent(Tuple.of(id), k -> new LinkedHashSet<>());
+                                        }
+                                        sb.append(drawEdge(cursor.getKey(), key, entry.getValue()));
+                                }
+                        }
+                }
+                for (var entry : unaryTupleToInterpretationsMap.entrySet()) {
+                        sb.append(drawElement(entry));
+                }
+                sb.append("}");
+                return sb.toString();
+        }
+
+        private StringBuilder drawElement(Map.Entry<Tuple, LinkedHashSet<Interpretation<?>>> entry) {
+                var sb = new StringBuilder();
+
+                var tableStyle =  " CELLSPACING=\"0\" BORDER=\"2\" CELLBORDER=\"0\" CELLPADDING=\"4\" STYLE=\"ROUNDED\"";
+
+                var key = entry.getKey();
+                var id = key.get(0);
+                var mainLabel = String.valueOf(id);
+                var interpretations = entry.getValue();
+                var backgroundColor = toBackgroundColorString(averageColor(interpretations));
+
+                sb.append(id);
+                sb.append(" [\n");
+                sb.append("\tfillcolor=\"").append(backgroundColor).append("\"\n");
+                sb.append("\tlabel=");
+                if (interpretations.isEmpty()) {
+                        sb.append("<<TABLE").append(tableStyle).append(">\n\t<TR><TD>").append(mainLabel).append("</TD></TR>");
+                }
+                else {
+                        sb.append("<<TABLE").append(tableStyle).append(">\n\t\t<TR><TD COLSPAN=\"3\" BORDER=\"2\" SIDES=\"B\">")
+                                        .append(mainLabel).append("</TD></TR>\n");
+                        for (var interpretation : interpretations) {
+                                var rawValue = interpretation.get(key);
+
+                                if (rawValue == null || rawValue.equals(TruthValue.FALSE) || rawValue.equals(false)) {
+                                        continue;
+                                }
+                                var color = "black";
+                                if (rawValue.equals(TruthValue.ERROR)) {
+                                        color = "red";
+                                }
+                                var value = truthValueToDot.getOrDefault(rawValue, rawValue.toString());
+                                var symbol = interpretation.getSymbol();
+
+                                if (symbol.valueType() == String.class) {
+                                        value = "\"" + value + "\"";
+                                }
+                                sb.append("\t\t<TR><TD><FONT COLOR=\"").append(color).append("\">")
+                                                .append(interpretation.getSymbol().name())
+                                                .append("</FONT></TD><TD><FONT COLOR=\"").append(color).append("\">")
+                                                .append("=</FONT></TD><TD><FONT COLOR=\"").append(color).append("\">").append(value)
+                                                .append("</FONT></TD></TR>\n");
+                        }
+                }
+                sb.append("\t\t</TABLE>>\n");
+                sb.append("]\n");
+
+                return sb;
+        }
+
+        private String drawEdge(Tuple edge, AnySymbol symbol, Interpretation<?> interpretation) {
+                var value = interpretation.get(edge);
+
+                if (value == null || value.equals(TruthValue.FALSE) || value.equals(false)) {
+                        return "";
+                }
+
+                var sb = new StringBuilder();
+                var style = "solid";
+                var color = "black";
+                if (value.equals(TruthValue.UNKNOWN)) {
+                        style = "dotted";
+                }
+                else if (value.equals(TruthValue.ERROR)) {
+                        style = "dashed";
+                        color = "red";
+                }
+
+                var from = edge.get(0);
+                var to = edge.get(1);
+                var name = symbol.name();
+                sb.append(from).append(" -> ").append(to)
+                                .append(" [\n\tstyle=").append(style)
+                                .append("\n\tcolor=").append(color)
+                                .append("\n\tfontcolor=").append(color)
+                                .append("\n\tlabel=\"").append(name)
+                                .append("\"]\n");
+                return sb.toString();
+        }
+
+        private String toBackgroundColorString(Integer[] backgroundColor) {
+                if (backgroundColor.length == 3)
+                        return String.format("#%02x%02x%02x", backgroundColor[0], backgroundColor[1], backgroundColor[2]);
+                else if (backgroundColor.length == 4)
+                        return String.format("#%02x%02x%02x%02x", backgroundColor[0], backgroundColor[1], backgroundColor[2],
+                                        backgroundColor[3]);
+                return null;
+        }
+
+        private Integer[] typeColor(String name) {
+                var random = new Random(name.hashCode());
+                return new Integer[] { random.nextInt(128) + 128, random.nextInt(128) + 128, random.nextInt(128) + 128 };
+        }
+
+        private Integer[] averageColor(Set<Interpretation<?>> interpretations) {
+                if(interpretations.isEmpty()) {
+                        return new Integer[]{256, 256, 256};
+                }
+                // TODO: Only use interpretations where the value is not false (or unknown)
+                var symbols = interpretations.stream()
+                                .map(i -> typeColor(i.getSymbol().name())).toArray(Integer[][]::new);
+
+
+
+                return new Integer[] {
+                                Arrays.stream(symbols).map(i -> i[0]).collect(Collectors.averagingInt(Integer::intValue)).intValue(),
+                                Arrays.stream(symbols).map(i -> i[1]).collect(Collectors.averagingInt(Integer::intValue)).intValue(),
+                                Arrays.stream(symbols).map(i -> i[2]).collect(Collectors.averagingInt(Integer::intValue)).intValue()
+                };
+        }
+
+        private String createDotForModelState(Version version) {
+                var currentVersion = model.getState();
+                model.restore(version);
+                var graph = createDotForCurrentModelState();
+                model.restore(currentVersion);
+                return graph;
+        }
+
+        private boolean saveDot(String dot, String filePath) {
+                File file = new File(filePath);
+                file.getParentFile().mkdirs();
+
+                try (FileWriter writer = new FileWriter(file)) {
+                        writer.write(dot);
+                } catch (Exception e) {
+                        e.printStackTrace();
+                        return false;
+                }
+                return true;
+        }
+
+        private boolean renderDot(String dot, String filePath) {
+                return renderDot(dot, FileFormat.SVG, filePath);
+        }
+
+        private boolean renderDot(String dot, FileFormat format, String filePath) {
+                try {
+                        Process process = new ProcessBuilder("dot", "-T" + format.getFormat(), "-o", filePath).start();
+
+                        OutputStream osToProcess = process.getOutputStream();
+                        PrintWriter pwToProcess = new PrintWriter(osToProcess);
+                        pwToProcess.write(dot);
+                        pwToProcess.close();
+                } catch (IOException e) {
+                        e.printStackTrace();
+                        return false;
+                }
+                return true;
+        }
+
+        @Override
+        public void addTransition(Version from, Version to, String action) {
+                designSpaceBuilder.append(states.get(from)).append(" -> ").append(states.get(to))
+                                .append(" [label=\"").append(transitionCounter++).append(": ").append(action).append("\"]\n");
+        }
+
+        @Override
+        public void addTransition(Version from, Version to, String action, Tuple activation) {
+                designSpaceBuilder.append(states.get(from)).append(" -> ").append(states.get(to))
+                                .append(" [label=\"").append(transitionCounter++).append(": ").append(action).append(" / ");
+
+
+                for (int i = 0; i < activation.getSize(); i++) {
+                        designSpaceBuilder.append(activation.get(i));
+                        if (i < activation.getSize() - 1) {
+                                designSpaceBuilder.append(", ");
+                        }
+                }
+                designSpaceBuilder.append("\"]\n");
+        }
+
+        @Override
+        public void addState(Version state) {
+                if (states.containsKey(state)) {
+                        return;
+                }
+                states.put(state, numberOfStates++);
+                designSpaceBuilder.append(states.get(state)).append(" [URL=\"./").append(states.get(state)).append(".svg\"]\n");
+        }
+
+        @Override
+        public void addState(Version state, Collection<Double> fitness) {
+                var labelBuilder = new StringBuilder();
+                for (var f : fitness) {
+                        labelBuilder.append(f).append(", ");
+                }
+                addState(state, labelBuilder.toString());
+        }
+
+        @Override
+        public void addState(Version state, String label) {
+                if (states.containsKey(state)) {
+                        return;
+                }
+                states.put(state, numberOfStates++);
+                designSpaceBuilder.append(states.get(state)).append(" [label = \"").append(states.get(state)).append(" (");
+                designSpaceBuilder.append(label);
+                designSpaceBuilder.append(")\"\n").append("URL=\"./").append(states.get(state)).append(".svg\"]\n");
+        }
+
+        @Override
+        public void addSolution(Version state) {
+                addState(state);
+                designSpaceBuilder.append(states.get(state)).append(" [shape = doublecircle]\n");
+        }
+
+        private String buildDesignSpaceDot() {
+                designSpaceBuilder.append("}");
+                return designSpaceBuilder.toString();
+        }
+
+        private boolean saveDesignSpace(String path) {
+                saveDot(buildDesignSpaceDot(), path + "/designSpace.dot");
+                for (var entry : states.entrySet()) {
+                        saveDot(createDotForModelState(entry.getKey()), path + "/" + entry.getValue() + ".dot");
+                }
+                return true;
+        }
+
+        private void renderDesignSpace(String path, Set<FileFormat> formats) {
+                File filePath = new File(path);
+                filePath.mkdirs();
+                if (renderStates) {
+                        for (var entry : states.entrySet()) {
+                                var stateId = entry.getValue();
+                                var stateDot = createDotForModelState(entry.getKey());
+                                for (var format : formats) {
+                                        if (format == FileFormat.DOT) {
+                                                saveDot(stateDot, path + "/" + stateId + ".dot");
+                                        }
+                                        else {
+                                                renderDot(stateDot, format, path + "/" + stateId + "." + format.getFormat());
+                                        }
+                                }
+                        }
+                }
+                if (renderDesignSpace) {
+                        var designSpaceDot = buildDesignSpaceDot();
+                        for (var format : formats) {
+                                if (format == FileFormat.DOT) {
+                                        saveDot(designSpaceDot, path + "/designSpace.dot");
+                                }
+                                else {
+                                        renderDot(designSpaceDot, format, path + "/designSpace." + format.getFormat());
+                                }
+                        }
+                }
+        }
+
+        @Override
+        public void visualize() {
+                renderDesignSpace(outputPath, formats);
+        }
+}
diff --git a/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/ModelVisualizerBuilderImpl.java b/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/ModelVisualizerBuilderImpl.java
new file mode 100644
index 00000000..e4d801d8
--- /dev/null
+++ b/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/ModelVisualizerBuilderImpl.java
@@ -0,0 +1,55 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.visualization.internal;
+
+import tools.refinery.store.adapter.AbstractModelAdapterBuilder;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.visualization.ModelVisualizerBuilder;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+public class ModelVisualizerBuilderImpl
+                extends AbstractModelAdapterBuilder<ModelVisualizeStoreAdapterImpl>
+                implements ModelVisualizerBuilder {
+        private String outputPath;
+        private boolean saveDesignSpace = false;
+        private boolean saveStates = false;
+        private Set<FileFormat> formats = new LinkedHashSet<>();
+
+        @Override
+        protected ModelVisualizeStoreAdapterImpl doBuild(ModelStore store) {
+                return new ModelVisualizeStoreAdapterImpl(store, outputPath, formats, saveDesignSpace, saveStates);
+        }
+
+        @Override
+        public ModelVisualizerBuilder withOutputpath(String outputpath) {
+                checkNotConfigured();
+                this.outputPath = outputpath;
+                return this;
+        }
+
+        @Override
+        public ModelVisualizerBuilder withFormat(FileFormat format) {
+                checkNotConfigured();
+                this.formats.add(format);
+                return this;
+        }
+
+        @Override
+        public ModelVisualizerBuilder saveDesignSpace() {
+                checkNotConfigured();
+                this.saveDesignSpace = true;
+                return this;
+        }
+
+        @Override
+        public ModelVisualizerBuilder saveStates() {
+                checkNotConfigured();
+                this.saveStates = true;
+                return this;
+        }
+}